Windows 11 25H2/26H2: FMfn/fltmgr.sys kernel pool memory growth during OneDrive activity. How can I identify the cause?

GaryHuerta-3110 0 Reputation points
2026-10-29T15:53:30.5766667+00:00

Problem description

I am investigating a severe, reproducible Windows 11 kernel memory pool issue that has persisted since August 2026.

The issue was originally observed on Windows 11 25H2 and continues after upgrading to Windows 11 26H2.

PoolMon consistently identifies FMfn (Paged), associated with Windows Filter Manager (fltmgr.sys / NAME_CACHE_NODE), as the largest individual kernel pool allocation tag.

The issue appears to be associated with filesystem activity, particularly OneDrive synchronization, although the root cause has not been conclusively identified.

Related Microsoft Feedback Hub report

This issue has also been submitted to Microsoft Feedback Hub with sanitized technical evidence, memory-growth graphs, and an investigation timeline.

https://aka.ms/AA14351t

System information

Windows 11 26H2 (previously 25H2)

64 GB physical RAM

NTFS filesystem

OneDrive synchronization enabled

Microsoft Cloud Files Filter (CldFlt) and third-party filesystem minifilters present

Observed memory consumption

At one point, Task Manager reported:

Measurement Memory consumption
Paged pool 20.5 GB
Nonpaged pool 11.4 GB
Combined kernel pools 31.9 GB
Physical RAM utilization Approximately 54 GB of 64 GB

PoolMon previously showed approximately 8.9 GiB associated with FMfn.

The computer experiences significant performance degradation and intermittent freezing as memory consumption increases.

Restarting temporarily reduces kernel pool usage, but the abnormal growth returns.

Recent reproduction: October 29, 2026

Following a system restart, memory monitoring recorded:

Time Paged pool Nonpaged pool Combined
9:35 AM 1.82 GiB 1.13 GiB 2.95 GiB
10:11 AM 6.61 GiB 3.51 GiB 10.12 GiB

Total increase: 7.17 GiB in approximately 36 minutes.

OneDrive was initially not running and was first detected running at approximately 9:38 AM.

Importantly, kernel pool growth was already occurring before OneDrive started. OneDrive therefore appears to be a possible accelerator or trigger, not necessarily the sole cause.

A PoolMon capture at 10:07 AM recorded:

Tag:                 FMfn
Pool type:           Paged
Allocations:         19,819,883
Frees:               16,148,660
Outstanding:         3,671,223
Bytes:               2,153,102,016
Average allocation:  586 bytes

Other prominent tags included File, NtfF, WCsc, Ntff, IoNm, and FMsl.

Troubleshooting already performed

Upgraded from Windows 11 25H2 to 26H2. The issue persisted.

Reset OneDrive and reproduced significant memory growth during synchronization activity.

Stopped OneDrive during testing and observed reduced or slower kernel pool accumulation.

Reviewed filesystem minifilters using fltmc.

Removed a legacy filesystem monitoring component, which reduced the accumulation rate but did not eliminate the problem.

Captured repeated PoolMon snapshots and Windows performance counter measurements.

Implemented ongoing memory monitoring to document paged/nonpaged pool growth and OneDrive process activity.

Repeatedly confirmed that rebooting temporarily resets pool consumption without resolving the underlying issue.

Questions for Windows kernel / filesystem specialists

1. What diagnostic approach would best identify which component is responsible for retaining millions of FMfn allocations?

2. Is there a known issue involving fltmgr.sys, NAME_CACHE_NODE, CldFlt, or filesystem minifilter interactions on Windows 11 25H2 or 26H2?

3. Could a third-party filesystem minifilter cause excessive Filter Manager allocations even if PoolMon attributes the allocations to FMfn rather than the third-party driver's own pool tag?

4. Would an ETW trace, Windows Performance Recorder profile, Driver Verifier configuration, or kernel memory dump provide the most useful evidence for identifying the underlying allocation or retention path?

5. Which specific ETW providers, tracing settings, or debugger commands would Microsoft recommend for investigating this behavior?

Additional information

This investigation has been ongoing for approximately 64 calendar days.

Sanitized memory-growth graphs, selected PoolMon statistics, and an investigation timeline have been prepared.

The available evidence establishes abnormal kernel memory accumulation and a repeated association with filesystem activity, but does not yet conclusively establish which driver or component is responsible.

I am seeking guidance on identifying the root cause rather than general memory optimization or routine Windows repair procedures.

Windows for business | Windows Client for IT Pros | Performance | System performance
0 comments No comments

3 answers

Sort by: Oldest
  1. AI answer

    2026-10-29T15:54:48.0833333+00:00

    Capture a short WPR trace with Pool usage, File I/O activity, and First Level Triage while the growth is occurring, then use WPA’s Pool → FMfn → Stack view to identify the allocation path and correlate it with file activity.

    1. Capture allocation stacks during a controlled reproduction

    WPR/WPA is the best first discriminator because PoolMon identifies the growing tag but not the call path responsible for creating or retaining the allocations. The Pool Usage profile records the pool tag and allocation stack; Microsoft’s documented pool-leak analysis pivots on Type, Paged, Pool Tag, Stack, Count, and Impacting Size.^1^

    1. Install the Windows Performance Toolkit from the Windows ADK if WPR/WPA is not already installed.
    2. Open Windows Performance Recorder as administrator.
    3. Select:
      • Pool usage
      • File I/O activity
      • First Level Triage
      • File logging mode
    4. Start recording immediately after a reboot, or just before the known rapid-growth interval.
    5. Reproduce for only as long as necessary—your 36-minute reproduction may produce a very large ETL. Stop after FMfn has increased materially.
    6. Save the ETL, open it in WPA, then select Trace → Load Symbols.
    7. Add Memory → Pool and arrange the table as:
      • Pool Tag
      • Paged
      • Impacting type
      • Pool Tag Module
      • Stack
      • Count
      • Impacting Size
      • Size
    8. Filter to FMfn, Paged, and preferably Impacting allocations. Expand Stack and sort by Impacting Size.

    Microsoft documents that the Pool table’s stack shows the code path leading to an allocation and that Impacting allocations contribute to steady-state usage.^2^

    Run comparable traces for:

    • OneDrive stopped.
    • OneDrive synchronizing.
    • Each removable third-party minifilter absent, using the vendor-supported disable/uninstall procedure.

    Because growth begins before OneDrive, do not treat OneDrive.exe or CldFlt as established causes. Compare the dominant FMfn allocation stacks and rates between runs.

    2. Interpret FMfn ownership correctly

    An FMfn mapping to fltmgr.sys identifies the component performing the allocation, not necessarily the minifilter whose operation caused Filter Manager to allocate it. A minifilter can request file-name information through FltGetFileNameInformation; depending on the query mode, Filter Manager checks or populates its name cache, and the returned structure is allocated from paged pool.^3^

    Therefore, yes: a third-party minifilter can plausibly drive Filter Manager name-cache allocations even when PoolMon displays a Filter Manager tag. PoolMon’s tag-to-driver mapping is based on pooltag.txt, and that mapping is not complete or a causal call-stack analysis.^4^

    The decisive evidence is whether WPA shows a third-party module in the allocation stack or whether controlled removal changes the allocation slope—not the mapped tag alone.

    3. Use targeted Filter Verifier only after identifying suspects

    Driver Verifier can deliberately crash or destabilize the machine. Create recoverable backups and use it on a test system if possible; do not select every driver or ntoskrnl.

    For one suspect third-party minifilter at a time:

    verifier.exe /standard /driver VendorFilter.sys
    

    For the minimal Windows 11 Filter Verifier checks:

    verifier.exe /ruleclasses 5 37 /driver VendorFilter.sys
    

    Filter Verifier tracks Filter Manager objects including name-information structures, contexts, callback data, file objects, filters, instances, and volumes. It can report leaked reference-counted objects when the filter unloads.^5^

    To disable verification:

    verifier /reset
    

    Restart afterward. Verification is most effective when restricted to named suspect drivers.^6^

    4. Preserve a kernel dump at high pool usage

    Configure System Properties → Advanced → Startup and Recovery → Settings → Write debugging information → Kernel memory dump. A kernel dump contains kernel and kernel-driver memory and is normally the most useful dump type for this investigation.^7^

    In WinDbg:

    .reload
    !poolused 4
    !poolfind FMfn 1
    !fltkd.filters
    !fltkd.frames
    !fltkd.volumes
    

    !poolused 4 sorts by paged-pool consumption; !poolfind FMfn 1 searches paged pool for that tag.^8^ ^9^ The !fltkd commands enumerate attached filters, frames, instances, and volumes.^10^

    Known-issue status

    The current Windows 11 25H2/26H2 Release Health information does not list this specific FMfn/Filter Manager/OneDrive pool-growth pattern.^11^ A closely matching public 25H2 report exists, but it has no accepted or recommended resolution and therefore does not establish a confirmed product defect.^12^

    For Microsoft escalation, provide the WPR ETL with symbols/load instructions, high-usage kernel dump, fltmc filters/instances/volumes output, exact OS build, PoolMon time series, and matched OneDrive-on/off traces.


    References

    1. Troubleshoot processes and threads by using WPR and WPA
    2. Exercise 3 - Track Driver Footprint and Dynamic Allocations During Boot
    3. FltGetFileNameInformation function (fltkernel.h)
    4. PoolMon Examples
    5. File System Filter Verification
    6. Driver Verifier
    7. Overview of memory dump file options for Windows
    8. Using the Kernel Debugger to Find a Kernel-Mode Memory Leak
    9. !poolfind
    10. Tools for minifilter development and testing
    11. Windows 11, version 25H2 known issues and notifications
    12. Windows 11 25H2 kernel pool leak: FMfn and File allocations retained ...
    AI-generated content may be incorrect. Read our transparency notes for more information.

    Was this answer helpful?

  2. Chance Maurice Niyonzima 825 Reputation points Independent Advisor
    2026-10-29T18:05:29.48+00:00

    Hello Gary,

    Thank you for posting your question on the Microsoft Windows Forum!

    The most important finding is that PoolMon has identified substantial growth in the FMfn tag, but PoolMon alone cannot determine which component is ultimately responsible for the allocations.

    Your investigation already establishes several important facts:

    The issue persists across both Windows 11 25H2 and 26H2.
    FMfn consistently dominates paged-pool growth.
    Growth begins before OneDrive starts.
    Removing one filesystem monitoring component reduced the growth rate.
    Rebooting resets the condition, but it eventually returns.
    

    This is significant because it suggests that while the allocations are attributed to:

    fltmgr.sys
    (NAME_CACHE_NODE)
    

    that does not automatically mean Filter Manager is the source of the leak.

    A filesystem minifilter can trigger Filter Manager to allocate and retain name-cache structures on its behalf. In that scenario, PoolMon correctly reports:

    FMfn
    

    while the underlying driver responsible is elsewhere.

    What the evidence currently suggests

    Based on the data provided so far, I would consider these possibilities more likely than a generic Windows memory leak:

    Cloud Files interaction (CldFlt)
    Third-party filesystem minifilter behavior
    Excessive file-name cache activity
    A regression within a Filter Manager code path exercised by a filter
    

    The current evidence does not conclusively identify which of those is responsible.

    Highest-value next step

    If the goal is to identify the component retaining the allocations, I would prioritize:

    Windows Performance Recorder (WPR)
    

    with:

    Pool Usage
    File I/O Activity
    First Level Triage
    

    enabled during a controlled reproduction.

    The reason is that:

    PoolMon tells you WHAT is growing.
    WPR/WPA helps determine WHO is causing it.
    

    After loading symbols in WPA, focus on:

    Memory → Pool
    → Pool Tag = FMfn
    → Stack
    

    and compare allocation stacks between:

    OneDrive stopped
    OneDrive synchronizing
    Third-party filesystem filters enabled
    Third-party filesystem filters disabled
    

    That comparison is likely to provide more actionable evidence than additional PoolMon captures.

    Regarding Driver Verifier

    I would not start with system-wide Driver Verifier.

    Given the scale of memory growth already observed, a safer approach would be:

    1. Identify suspect minifilters via WPR/WPA.
    2. Verify only those drivers.
    

    using targeted verification rather than all installed drivers.

    Regarding kernel dumps

    A kernel memory dump captured while:

    FMfn consumption is high
    

    would be extremely valuable because it can be correlated with:

    !poolused
    !poolfind FMfn
    !fltkd.filters
    !fltkd.instances
    

    to determine whether specific filters or objects are retaining references.

    Microsoft References

    One clarification

    Could you share the current output of:

    fltmc filters
    

    and:

    fltmc instances
    

    particularly for any non-Microsoft minifilters?

    Since removing one legacy filesystem-monitoring component reduced the growth rate, understanding the remaining filter stack may help determine whether the next investigation should focus on:

    CldFlt
    a third-party minifilter
    or Filter Manager itself
    

    before enabling Driver Verifier or collecting kernel dumps.

    I hope this answer has brought you useful information. If so, please click on "Accept Answer" and consider upvoting it. Doing so helps other community members identify useful solutions to similar issues.

    Was this answer helpful?


  3. Deleted

    This answer has been deleted due to a violation of our Code of Conduct. The answer was manually reported or identified through automated detection before action was taken. Please refer to our Code of Conduct for more information.


    Comments have been turned off. Learn more

Your answer

Answers can be marked as 'Accepted' by the question author and 'Recommended' by moderators, which helps users know the answer solved the author's problem.