FileSystemWatcher on Linux: event-processing thread exits silently after interleaved directory renames (unpaired IN_MOVED_FROM handling) - watcher stops receiving events, no Error raised. #133420

// fswkill - reproducer for the .NET 10 Linux FileSystemWatcher silent death
// under interleaved (name-colliding) directory renames.
// Exit codes: 0 = survived, 2 = watcher died silently, 3 = died but Error fired.

using System;
using System.IO;
using System.Threading;

class Program
{
    static long sEvents;
    static volatile string sLastCanarySeen = "";
    static volatile bool sErrorFired;

    static int Main(string[] args)
    {
        int maxRounds = args.Length > 0 ? int.Parse(args[0]) : 5000;
        string root = Path.Combine(
            args.Length > 1 ? args[1] : Path.GetTempPath(),
            "fswkill-" + Environment.ProcessId);

        Console.WriteLine("runtime: " + Environment.Version + " | root: " + root);

        string code = Path.Combine(root, "code");
        string lib = Path.Combine(root, "lib");
        string src = Path.Combine(root, "src");

        Directory.CreateDirectory(Path.Combine(code, "child"));
        Directory.CreateDirectory(Path.Combine(lib, "child"));
        Directory.CreateDirectory(Path.Combine(root, "beacon"));
        File.WriteAllText(Path.Combine(code, "child", "f.txt"), "x");
        File.WriteAllText(Path.Combine(lib, "child", "f.txt"), "x");

        using FileSystemWatcher fsw = new FileSystemWatcher(root);
        fsw.IncludeSubdirectories = true;
        fsw.NotifyFilter = NotifyFilters.FileName | NotifyFilters.DirectoryName
            | NotifyFilters.LastWrite | NotifyFilters.CreationTime | NotifyFilters.Size;

        FileSystemEventHandler onAny = delegate (object s, FileSystemEventArgs e)
        {
            Interlocked.Increment(ref sEvents);
            if (e.Name != null && e.Name.StartsWith("canary_"))
                sLastCanarySeen = e.Name;
        };
        fsw.Created += onAny;
        fsw.Changed += onAny;
        fsw.Deleted += onAny;
        fsw.Renamed += delegate { Interlocked.Increment(ref sEvents); };
        fsw.Error += delegate (object s, ErrorEventArgs e)
        {
            sErrorFired = true;
            Console.WriteLine("!! Error event fired: " + e.GetException());
        };
        fsw.EnableRaisingEvents = true;

        // background lock-file-style traffic keeps the inotify reads chunked
        bool stop = false;
        Thread writer = new Thread(delegate ()
        {
            string beacon = Path.Combine(root, "beacon", "lck");
            int i = 0;
            while (!Volatile.Read(ref stop))
            {
                try { File.WriteAllText(beacon, i++.ToString()); } catch { }
                Thread.Sleep(1);
            }
        });
        writer.IsBackground = true;
        writer.Start();

        Console.WriteLine("baseline: " + Vitals());

        for (int round = 1; round <= maxRounds; round++)
        {
            // the colliding rename chain (name reuse is the essential ingredient)
            try
            {
                Directory.Move(lib, src);
                Directory.Move(code, lib);
                Directory.Move(lib, code);
                Directory.Move(src, lib);
            }
            catch (Exception ex)
            {
                Console.WriteLine("rename hiccup at round " + round + ": " + ex.Message);
                EnsureLayout(code, lib, src);
                Thread.Sleep(20);
            }

            if (round % 25 != 0)
                continue;

            if (!CanaryDelivered(root, round))
            {
                Volatile.Write(ref stop, true);
                Console.WriteLine("== VERDICT: watcher DEAD at round " + round
                    + " | events delivered: " + Interlocked.Read(ref sEvents)
                    + " | Error fired: " + sErrorFired);
                Console.WriteLine("post-mortem: " + Vitals()
                    + " (watcher still armed: " + fsw.EnableRaisingEvents + ")");
                return sErrorFired ? 3 : 2;
            }
        }

        Volatile.Write(ref stop, true);
        Console.WriteLine("== VERDICT: SURVIVED " + maxRounds + " rounds | events delivered: "
            + Interlocked.Read(ref sEvents) + " | " + Vitals());
        return 0;
    }

    static bool CanaryDelivered(string root, int round)
    {
        string name = "canary_" + round;
        try { File.WriteAllText(Path.Combine(root, name + ".txt"), "alive?"); }
        catch (Exception ex) { Console.WriteLine("canary write failed: " + ex.Message); }

        for (int waited = 0; waited < 2000; waited += 10)
        {
            if (sLastCanarySeen.StartsWith(name))
                return true;
            Thread.Sleep(10);
        }
        return false;
    }

    static void EnsureLayout(string code, string lib, string src)
    {
        try
        {
            if (!Directory.Exists(lib) && Directory.Exists(src)) Directory.Move(src, lib);
            if (!Directory.Exists(code) && Directory.Exists(src)) Directory.Move(src, code);
            if (!Directory.Exists(code)) Directory.CreateDirectory(Path.Combine(code, "child"));
            if (!Directory.Exists(lib)) Directory.CreateDirectory(Path.Combine(lib, "child"));
        }
        catch { }
    }

    static string Vitals()
    {
        if (!OperatingSystem.IsLinux())
            return "(vitals: non-linux)";

        int inotifyFds = 0;
        try
        {
            foreach (string fd in Directory.GetFiles("/proc/self/fd"))
            {
                try
                {
                    FileSystemInfo target = new FileInfo(fd).ResolveLinkTarget(false);
                    if (target != null && target.FullName.Contains("inotify"))
                        inotifyFds++;
                }
                catch { }
            }
        }
        catch { }

        int watcherThreads = 0;
        try
        {
            foreach (string task in Directory.GetDirectories("/proc/self/task"))
            {
                try
                {
                    if (File.ReadAllText(Path.Combine(task, "comm")).Contains(".NET File Watch"))
                        watcherThreads++;
                }
                catch { }
            }
        }
        catch { }

        return "inotify fds: " + inotifyFds + ", '.NET File Watcher' threads: " + watcherThreads;
    }
}