Add small timeout to FSW MOVED_FROM polling on Linux

inotify handles renames via a pair of MOVED_FROM and MOVED_TO events that are potentially delivered separately and that for some moves may not have a MOVED_TO at all (such as if moving a file out of the watched path). This means that if we get a MOVED_FROM and we haven't yet received any further events, we have a choice:
- Do we wait until we get another event to make a decision about how to process the MOVED_FROM, seeing if the next event is a MOVED_TO (in which case the MOVED_FROM is treated as part of the rename) or if it's something else (in which case the MOVED_FROM is treated as a deletion).
- Do we assume we won't get an associated MOVED_TO, and immediately treat the MOVED_FROM as a deletion.

We originally implemented the former, as it doesn't suffer from the race condition the latter suffers from, which might treat some MOVED_FROM/MOVED_TO pairs as a rename and others as a creation/deletion, based on timing. But it suffers from another problem, that if you just get a MOVED_FROM and no other event arrives (or arrives for a while) the event associated with the MOVED_FROM could be delayed (indefinitely if another event never arrives). #2587 switched from the former to the latter, under the assumption that it's the least bad of the two options.

As discussed at #2655 (comment), a compromise can be to wait a few milliseconds for the MOVED_TO to arrive, as that's been shown to handle a vast majority of the cases where a MOVED_TO is on its way.  This commit simply adds that timeout to our call to poll.  As long as this code was being modified, the commit also adds a try/finally around the handle manipulation, just in case an exception happens to emerge.

Author: stephentoub

src/System.IO.FileSystem.Watcher/src/System/IO/FileSystemWatcher.Linux.cs

@@ -601,15 +601,34 @@ private void ProcessEvents()
                                 // so we will send a DELETE for this event and a CREATE when the MOVED_TO is eventually processed.
                                 if (_bufferPos == _bufferAvailable)
                                 {
-                                    bool success = false;
-                                    Interop.libc.PollFlags resultFlags;
-                                    _inotifyHandle.DangerousAddRef(ref success);
-                                    Debug.Assert(success, "Failed to add-ref inotify handle");
-                                    int result = Interop.libc.poll(_inotifyHandle.DangerousGetHandle().ToInt32(), Interop.libc.PollFlags.POLLIN, 0, out resultFlags);
-                                    _inotifyHandle.DangerousRelease();
+                                    int pollResult;
+                                    bool gotRef = false;
+                                    try
+                                    {
+                                        _inotifyHandle.DangerousAddRef(ref gotRef);
+
+                                        // Do the poll with a small timeout value.  Community research showed that a few milliseconds
+                                        // was enough to allow the vast majority of MOVED_TO events that were going to show
+                                        // up to actually arrive.  This doesn't need to be perfect; there's always the chance
+                                        // that a MOVED_TO could show up after whatever timeout is specified, in which case
+                                        // it'll just result in a delete + create instead of a rename.  We need the value to be
+                                        // small so that we don't significantly delay the delivery of the deleted event in case
+                                        // that's actually what's needed (otherwise it'd be fine to block indefinitely waiting
+                                        // for the next event to arrive).
+                                        const int MillisecondsTimeout = 2;
+                                        Interop.libc.PollFlags resultFlags;
+                                        pollResult = Interop.libc.poll(_inotifyHandle.DangerousGetHandle().ToInt32(), Interop.libc.PollFlags.POLLIN, MillisecondsTimeout, out resultFlags);
+                                    }
+                                    finally
+                                    {
+                                        if (gotRef)
+                                        {
+                                            _inotifyHandle.DangerousRelease();
+                                        }
+                                    }
 
                                     // If we error or don't have any signaled handles, send the deleted event
-                                    if (result <= 0)
+                                    if (pollResult <= 0)
                                     {
                                         // There isn't any more data in the queue so this is a deleted event
                                         watcher.NotifyFileSystemEventArgs(WatcherChangeTypes.Deleted, expandedName);