hv_netvsc: use kmap_local_page in netvsc_copy_to_send_buf
Subsystems (5)
PATCH 1/1 hv_netvsc: use kmap_local_page in netvsc_copy_to_send_buf
From: Anton Leontev <[email protected]>
netvsc_copy_to_send_buf() copies skb fragment pages into the shared VMBus send buffer using phys_to_virt() on the fragment PFN. On 32-bit x86 with CONFIG_HIGHMEM=y, phys_to_virt() (i.e. __va()) is only valid for LOWMEM addresses below 896 MiB. For a HIGHMEM page it returns an address that has no kernel page table entry and lies outside the kernel direct map, so the subsequent memcpy() faults. As this happens on the transmit softirq path, the fault is fatal.
A HIGHMEM fragment reaches this path whenever the page backing an skb fragment lives above the LOWMEM boundary, which is common on a 32-bit guest with several GiB of RAM (for example when the in-kernel NFS server splices page cache pages directly into the reply skb).
Map the fragment page on demand with kmap_local_page()/kunmap_local() instead. Using pfn_to_page() on pb[i].pfn maps exactly the page described by the page buffer entry. On configurations without HIGHMEM (amd64, i386 without CONFIG_HIGHMEM) kmap_local_page() reduces to page_address(), so this is a no-op there.
--- drivers/net/hyperv/netvsc.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)
drivers/net/hyperv/netvsc.c +4 -1
@@ -12,6 +12,7 @@#include <linux/sched.h> #include <linux/wait.h> #include <linux/mm.h> +#include <linux/highmem.h> #include <linux/delay.h> #include <linux/io.h> #include <linux/slab.h>
@@ -965,11 +966,13 @@ static void netvsc_copy_to_send_buf(struct netvsc_device *net_device, }for (i =0 ; i < page_count; i++) { -char *src =phys_to_virt (pb[i].pfn <<HV_HYP_PAGE_SHIFT ); +struct page *page =pfn_to_page (pb[i].pfn); +char *src =kmap_local_page (page);u32 offset = pb[i].offset;u32 len = pb[i].len;memcpy (dest, (src + offset), len); +kunmap_local (src); dest += len; }
Signature · 1 line
2.43.0
Haiyang Zhang
maintainerQuoted 20 lines
-----Original Message-----
From: LeantionX <[email protected]>
Sent: Tuesday, June 2, 2026 11:52 AM
To: [email protected]
Cc: [email protected]; KY Srinivasan <[email protected]>; Haiyang Zhang <[email protected]>; [email protected]; Dexuan Cui <[email protected]>; Long Li <[email protected]>; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; linux- [email protected]; Anton Leontev <[email protected]>
Subject: [EXTERNAL] [PATCH net]hv_netvsc: usekmap_local_pageinnetvsc_copy_to_send_buf[You don't often get email from [email protected]. Learn why this is important at https://aka.ms/LearnAboutSenderIdentification ]
From: Anton Leontev <[email protected]>
Quoted 7 lines
netvsc_copy_to_send_buf()copies skb fragment pages into the shared VMBus send buffer usingphys_to_virt()on the fragment PFN. On 32-bit x86 withCONFIG_HIGHMEM=y,phys_to_virt()(i.e.__va()) is only valid for LOWMEM addresses below 896 MiB. For a HIGHMEM page it returns an address that has no kernel page table entry and lies outside the kernel direct map, so the subsequentmemcpy()faults. As this happens on the transmit softirq path, the fault is fatal.
Please include the stack trace in patch description.
Quoted 10 lines
A HIGHMEM fragment reaches this path whenever the page backing an skb fragment lives above the LOWMEM boundary, which is common on a 32-bit guest with several GiB of RAM (for example when the in-kernel NFS server splices page cache pages directly into the reply skb).
Map the fragment page on demand with kmap_local_page()/kunmap_local() instead. Using
pfn_to_page()on pb[i].pfn maps exactly the page described by the page buffer entry. On configurations without HIGHMEM (amd64, i386 withoutCONFIG_HIGHMEM)kmap_local_page()reduces topage_address(), so this is a no-op there.
So, on 64bit kernel, it has no performance impact?
Thanks,
- Haiyang
Quoted 41 lines
Quoted 21 lines
-----Original Message-----
From: LeantionX <[email protected]>
Sent: Tuesday, June 2, 2026 11:52 AM
To: [email protected]
Cc: [email protected]; KY Srinivasan <[email protected]>; Haiyang Zhang <[email protected]>; [email protected]; Dexuan Cui <[email protected]>; Long Li <[email protected]>; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; linux- [email protected]; Anton Leontev <[email protected]>
Subject: [EXTERNAL] [PATCH net]hv_netvsc: usekmap_local_pageinnetvsc_copy_to_send_buf[You don't often get email from [email protected]. Learn why this is important at https://aka.ms/LearnAboutSenderIdentification ]
From: Anton Leontev <[email protected]>
Quoted 7 lines
netvsc_copy_to_send_buf()copies skb fragment pages into the shared VMBus send buffer usingphys_to_virt()on the fragment PFN. On 32-bit x86 withCONFIG_HIGHMEM=y,phys_to_virt()(i.e.__va()) is only valid for LOWMEM addresses below 896 MiB. For a HIGHMEM page it returns an address that has no kernel page table entry and lies outside the kernel direct map, so the subsequentmemcpy()faults. As this happens on the transmit softirq path, the fault is fatal.Please include the stack trace in patch description.
Quoted 10 lines
A HIGHMEM fragment reaches this path whenever the page backing an skb fragment lives above the LOWMEM boundary, which is common on a 32-bit guest with several GiB of RAM (for example when the in-kernel NFS server splices page cache pages directly into the reply skb).
Map the fragment page on demand with kmap_local_page()/kunmap_local() instead. Using
pfn_to_page()on pb[i].pfn maps exactly the page described by the page buffer entry. On configurations without HIGHMEM (amd64, i386 withoutCONFIG_HIGHMEM)kmap_local_page()reduces topage_address(), so this is a no-op there.
Quoted 5 lines
So, on 64bit kernel, it has no performance impact?
Thanks,
- Haiyang
Correct. On 64-bit (and any !CONFIG_HIGHMEM config) all pages are permanently present in the kernel direct map, so kmap_local_page() folds to page_address() and kunmap_local() is a no-op. The generated code is therefore equivalent to the previous direct-map access, with no extra mapping cost on the tx path.
The kmap is only meaningful on 32-bit CONFIG_HIGHMEM, where the fragment page may live above the LOWMEM boundary and the old phys_to_virt() result is invalid.
Thanks,
Anton
[email protected]
AI reviewThank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [Critical] Passing a Hyper-V PFN directly to `pfn_to_page()` causes out-of-bounds memory accesses on…
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Critical] Passing a Hyper-V PFN directly to pfn_to_page() causes out-of-bounds memory accesses on architectures where PAGE_SIZE > 4KB (e.g., ARM64 with 64KB pages), and loses the intra-page chunk offset. --
commit a844fbf018cd37eedc9a1f0aea79d6235c00bec3
Author: Anton Leontev <[email protected]>
hv_netvsc: use kmap_local_page in netvsc_copy_to_send_buf
This commit replaces phys_to_virt() with kmap_local_page() in netvsc_copy_to_send_buf() to map skb fragment pages. This is intended to fix a fatal transmit softirq fault on 32-bit x86 configurations with HIGHMEM, where phys_to_virt() is only valid for LOWMEM addresses.
Quoted 4 lines
drivers/net/hyperv/netvsc.c +0
-0
[ ... ]
drivers/net/hyperv/netvsc.c static void netvsc_copy_to_send_buf(struct netvsc_device *net_device, · line 970
Quoted 7 lines
drivers/net/hyperv/netvsc.c +2
-1@@ -965,11 +966,13 @@ static void netvsc_copy_to_send_buf(struct netvsc_device *net_device, }for (i =0 ; i < page_count; i++) { -char *src =phys_to_virt (pb[i].pfn <<HV_HYP_PAGE_SHIFT ); +struct page *page =pfn_to_page (pb[i].pfn); +char *src =kmap_local_page (page);
[Severity: Critical]
Does this cause out-of-bounds memory accesses on architectures with a native page size greater than 4KB?
The pb[i].pfn field contains a Hyper-V PFN, which always operates at 4KB granularity. Passing this directly to pfn_to_page() assumes it is a native Linux PFN.
On architectures where the native page size is larger than 4KB (such as ARM64 with 64KB pages), the Hyper-V PFN is significantly larger than the corresponding native Linux PFN. Using it with pfn_to_page() would return an invalid struct page pointer.
Calling kmap_local_page() on this invalid pointer in netvsc_copy_to_send_buf() and subsequently reading from it could lead to memory corruption, out-of-bounds accesses, or kernel panics.
Could this also lose the native page offset of the original 4KB chunk within the larger Linux page, resulting in an incorrect read offset during the subsequent memcpy?
Quoted 7 lines
drivers/net/hyperv/netvsc.c +1
-0u32 offset = pb[i].offset;u32 len = pb[i].len;memcpy (dest, (src + offset), len); +kunmap_local (src); dest += len; }
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1
You are right, thanks for catching this. pb[i].pfn is a Hyper-V PFN at 4K granularity, so passing it directly to pfn_to_page() is wrong where PAGE_SIZE > 4K, and it also drops the intra-page offset. Fixed in v2 by reconstructing the physical address and using phys_to_page() + offset_in_page(). Built for i386 (HIGHMEM) and arm64 (64K pages).
Thanks,
Anton
ср, 3 июн. 2026 г. в 18:53, <[email protected]>:
Quoted 61 lines
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Critical] Passing a Hyper-V PFN directly topfn_to_page()causes out-of-bounds memory accesses on architectures wherePAGE_SIZE > 4KB(e.g., ARM64 with 64KB pages), and loses the intra-page chunk offset. --commit
a844fbf018cd37eedc9a1f0aea79d6235c00bec3
Author: Anton Leontev <[email protected]>
hv_netvsc: usekmap_local_pageinnetvsc_copy_to_send_bufThis commit replaces
phys_to_virt()withkmap_local_page()innetvsc_copy_to_send_buf()to map skb fragment pages. This is intended to fix a fatal transmit softirq fault on 32-bit x86 configurations with HIGHMEM, wherephys_to_virt()is only valid for LOWMEM addresses.Quoted 4 lines
drivers/net/hyperv/netvsc.c +0
-0[ ... ]
drivers/net/hyperv/netvsc.c static void netvsc_copy_to_send_buf(struct netvsc_device *net_device, · line 970
Quoted 7 lines
drivers/net/hyperv/netvsc.c +2
-1@@ -965,11 +966,13 @@ static void netvsc_copy_to_send_buf(struct netvsc_device *net_device, }for (i =0 ; i < page_count; i++) { -char *src =phys_to_virt (pb[i].pfn <<HV_HYP_PAGE_SHIFT ); +struct page *page =pfn_to_page (pb[i].pfn); +char *src =kmap_local_page (page);[Severity: Critical]
Does this cause out-of-bounds memory accesses on architectures with a native page size greater than 4KB?The pb[i].pfn field contains a Hyper-V PFN, which always operates at 4KB granularity. Passing this directly to
pfn_to_page()assumes it is a native Linux PFN.On architectures where the native page size is larger than 4KB (such as ARM64 with 64KB pages), the Hyper-V PFN is significantly larger than the corresponding native Linux PFN. Using it with
pfn_to_page()would return an invalid struct page pointer.Calling
kmap_local_page()on this invalid pointer innetvsc_copy_to_send_buf()and subsequently reading from it could lead to memory corruption, out-of-bounds accesses, or kernel panics.Could this also lose the native page offset of the original 4KB chunk within the larger Linux page, resulting in an incorrect read offset during the subsequent memcpy?
drivers/net/hyperv/netvsc.c static void netvsc_copy_to_send_buf(struct netvsc_device *net_device, · line 977
Quoted 7 lines
drivers/net/hyperv/netvsc.c +1
-0u32 offset = pb[i].offset;u32 len = pb[i].len;memcpy (dest, (src + offset), len); +kunmap_local (src); dest += len; }--
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1
PATCH v2 1/1 hv_netvsc: use kmap_local_page in netvsc_copy_to_send_buf
In reply to LeantionXnetvsc_copy_to_send_buf() copies skb fragment pages into the shared VMBus send buffer using phys_to_virt() on the fragment PFN. On 32-bit x86 with CONFIG_HIGHMEM=y, phys_to_virt() (i.e. __va()) is only valid for LOWMEM addresses below 896 MiB. For a HIGHMEM page it returns an address that has no kernel page table entry and lies outside the kernel direct map, so the subsequent memcpy() faults. As this happens on the transmit softirq path, the fault is fatal.
A HIGHMEM fragment reaches this path whenever the page backing an skb fragment lives above the LOWMEM boundary, which is common on a 32-bit guest with several GiB of RAM (for example when the in-kernel NFS server splices page cache pages directly into the reply skb).
pb[i].pfn is a Hyper-V PFN at HV_HYP_PAGE_SIZE (4K) granularity. The physical address is reconstructed first and phys_to_page() is used to obtain the native struct page, with offset_in_page() added so the in-page offset stays correct where PAGE_SIZE > HV_HYP_PAGE_SIZE (e.g. arm64 with 64K pages). The page is then mapped on demand with kmap_local_page()/kunmap_local(). On !CONFIG_HIGHMEM configs kmap_local_page() reduces to page_address(), so this is a no-op there.
---
v2:
- Reconstruct the physical address from the Hyper-V PFN and use phys_to_page() + offset_in_page() instead of pfn_to_page() on the raw PFN, correct where PAGE_SIZE > 4K (e.g. arm64 64K pages). Reported by Haiyang Zhang.
- Built for i386 (CONFIG_HIGHMEM) and arm64 (64K pages).
drivers/net/hyperv/netvsc.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-)
drivers/net/hyperv/netvsc.c +6 -2
@@ -12,6 +12,7 @@#include <linux/sched.h> #include <linux/wait.h> #include <linux/mm.h> +#include <linux/highmem.h> #include <linux/delay.h> #include <linux/io.h> #include <linux/slab.h>
@@ -965,11 +966,14 @@ static void netvsc_copy_to_send_buf(struct netvsc_device *net_device, }for (i =0 ; i < page_count; i++) { -char *src =phys_to_virt (pb[i].pfn <<HV_HYP_PAGE_SHIFT ); -u32 offset = pb[i].offset; +phys_addr_t paddr = pb[i].pfn <<HV_HYP_PAGE_SHIFT ; +struct page *page =phys_to_page (paddr); +u32 offset =offset_in_page (paddr) + pb[i].offset;u32 len = pb[i].len; +char *src =kmap_local_page (page);memcpy (dest, (src + offset), len); +kunmap_local (src); dest += len; }
Signature · 1 line
2.43.0
[email protected]
AI reviewThank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [Critical] The patch replaces `phys_to_virt()` with `kmap_local_page()` in `netvsc_copy_to_send_buf()` to…
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Critical] The patch replaces phys_to_virt() with kmap_local_page() in netvsc_copy_to_send_buf() to support HIGHMEM SKB fragments. However, kmap_local_page() maps exactly one page (e.g., 4096 bytes). SKB fragments (such as those from TCP sends using sk_page_frag() or NFS) can be backed by compound pages where the fragment size (len) exceeds a single page, or where offset + len crosses a page boundary. The pb array populated by init_page_array() contains exactly one entry per fragment, meaning pb[i].len can exceed PAGE_SIZE. When memcpy(dest, src + offset, len) is called, it will read past the 4KB window mapped by kmap_local_page(). On 32-bit HIGHMEM systems, this accesses adjacent unmapped or unrelated fixmap slots, causing a fatal page fault or memory leakage. --
commit dfe36312b193784583b28a894f895984d7d0ebba
Author: Anton Leontev <[email protected]>
hv_netvsc: use kmap_local_page in netvsc_copy_to_send_buf
This patch replaces phys_to_virt() with kmap_local_page() to support HIGHMEM SKB fragments that are beyond the LOWMEM boundary on 32-bit systems.
Quoted 4 lines
drivers/net/hyperv/netvsc.c +0
-0
[ ... ]
drivers/net/hyperv/netvsc.c static void netvsc_copy_to_send_buf(struct netvsc_device *net_device, · line 975
Quoted 13 lines
drivers/net/hyperv/netvsc.c +4
-2@@ -965,11 +966,14 @@ static void netvsc_copy_to_send_buf(struct netvsc_device *net_device, }for (i =0 ; i < page_count; i++) { -char *src =phys_to_virt (pb[i].pfn <<HV_HYP_PAGE_SHIFT ); -u32 offset = pb[i].offset; +phys_addr_t paddr = pb[i].pfn <<HV_HYP_PAGE_SHIFT ; +struct page *page =phys_to_page (paddr); +u32 offset =offset_in_page (paddr) + pb[i].offset;u32 len = pb[i].len; +char *src =kmap_local_page (page);memcpy (dest, (src + offset), len);
[Severity: Critical]
Will this memcpy() read beyond the 1-page mapping established by kmap_local_page()?
If the fragment size (len) plus offset exceeds PAGE_SIZE, it seems memcpy() will read past the locally mapped window. SKB fragments can be backed by compound pages where the fragment size exceeds a single page, and init_page_array() assigns the full fragment size to pb[i].len:
drivers/net/hyperv/netvsc_drv.c:init_page_array() {
...
cur_pb->offset = offset_in_hvpage(offset);
cur_pb->len = skb_frag_size(frag);
cur_pb->pfn = pfn + (offset >> HV_HYP_PAGE_SHIFT);
...
}Other parts of the subsystem also document that a pb entry can cross page boundaries:
drivers/net/hyperv/netvsc.c:netvsc_build_mpb_array() {
...
/* Each entry in the input "pb" array must describe a contiguous range
* of guest physical memory so that the pfns are sequential if the range
* crosses a page boundary. */
...
for (j = 0; j < HVPFN_UP(offset + len); j++)
mpb_entry->pfnArray[j] = pb[i].pfn + j;
...
}Could this regression cause a fatal page fault on 32-bit HIGHMEM guests when an SKB fragment crosses a page boundary, or leak unrelated fixmap memory if the adjacent slot happens to be mapped?
Quoted 4 lines
drivers/net/hyperv/netvsc.c +1
-0+kunmap_local (src); dest += len; }
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1
You are right, thanks. Since 41a6328b2c55 ("hv_netvsc: Preserve contiguous PFN grouping in the page buffer array") a pb entry describes a full physically contiguous fragment and pb[i].len can exceed PAGE_SIZE, while kmap_local_page() maps a single page. v3 copies page by page, splitting at native page boundaries, and was posted as a new thread per netdev process.
чт, 4 июн. 2026 г. в 19:39, <[email protected]>:
Quoted 74 lines
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Critical] The patch replacesphys_to_virt()withkmap_local_page()innetvsc_copy_to_send_buf()to support HIGHMEM SKB fragments. However,kmap_local_page()maps exactly one page (e.g., 4096 bytes). SKB fragments (such as those from TCP sends usingsk_page_frag()or NFS) can be backed by compound pages where the fragment size (len) exceeds a single page, or whereoffset + lencrosses a page boundary. Thepbarray populated byinit_page_array()contains exactly one entry per fragment, meaningpb[i].lencan exceedPAGE_SIZE. Whenmemcpy(dest, src + offset, len)is called, it will read past the 4KB window mapped bykmap_local_page(). On 32-bit HIGHMEM systems, this accesses adjacent unmapped or unrelated fixmap slots, causing a fatal page fault or memory leakage. --commit
dfe36312b193784583b28a894f895984d7d0ebba
Author: Anton Leontev <[email protected]>
hv_netvsc: usekmap_local_pageinnetvsc_copy_to_send_bufThis patch replaces
phys_to_virt()withkmap_local_page()to support HIGHMEM SKB fragments that are beyond the LOWMEM boundary on 32-bit systems.Quoted 4 lines
drivers/net/hyperv/netvsc.c +0
-0[ ... ]
drivers/net/hyperv/netvsc.c static void netvsc_copy_to_send_buf(struct netvsc_device *net_device, · line 975
Quoted 13 lines
drivers/net/hyperv/netvsc.c +4
-2@@ -965,11 +966,14 @@ static void netvsc_copy_to_send_buf(struct netvsc_device *net_device, }for (i =0 ; i < page_count; i++) { -char *src =phys_to_virt (pb[i].pfn <<HV_HYP_PAGE_SHIFT ); -u32 offset = pb[i].offset; +phys_addr_t paddr = pb[i].pfn <<HV_HYP_PAGE_SHIFT ; +struct page *page =phys_to_page (paddr); +u32 offset =offset_in_page (paddr) + pb[i].offset;u32 len = pb[i].len; +char *src =kmap_local_page (page);memcpy (dest, (src + offset), len);[Severity: Critical]
Will thismemcpy()read beyond the 1-page mapping established bykmap_local_page()?If the fragment size (len) plus offset exceeds
PAGE_SIZE, it seemsmemcpy()will read past the locally mapped window. SKB fragments can be backed by compound pages where the fragment size exceeds a single page, andinit_page_array()assigns the full fragment size to pb[i].len:drivers/net/hyperv/netvsc_drv.c:init_page_array() { ... cur_pb->offset = offset_in_hvpage(offset); cur_pb->len = skb_frag_size(frag); cur_pb->pfn = pfn + (offset >> HV_HYP_PAGE_SHIFT); ... }Other parts of the subsystem also document that a pb entry can cross page boundaries:
drivers/net/hyperv/netvsc.c:netvsc_build_mpb_array() { ... /* Each entry in the input "pb" array must describe a contiguous range * of guest physical memory so that the pfns are sequential if the range * crosses a page boundary. */ ... for (j = 0; j < HVPFN_UP(offset + len); j++) mpb_entry->pfnArray[j] = pb[i].pfn + j; ... }Could this regression cause a fatal page fault on 32-bit HIGHMEM guests when an SKB fragment crosses a page boundary, or leak unrelated fixmap memory if the adjacent slot happens to be mapped?
drivers/net/hyperv/netvsc.c static void netvsc_copy_to_send_buf(struct netvsc_device *net_device, · line 979
Quoted 4 lines
drivers/net/hyperv/netvsc.c +1
-0+kunmap_local (src); dest += len; }--
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1