runtime: Deadlock in Linux Socket code

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace AppNamespace
{
    public sealed class Acceptor : IDisposable
    {
        public static event Action<Action<Task>> FatalError;

        private SynchronizationContext mContext;
        private Socket mAcceptor;
        private SocketAsyncEventArgs mAcceptEvent;
        private Action<Socket> mOnAccept;
        private int mPort;

        public Acceptor(IPAddress ip, int port, Action<Socket> onAccept)
        {
            if (onAccept == null)
                throw new ArgumentNullException("onAccept");

            // create the endpoint early to validate the port
            var endpoint = new IPEndPoint(ip, port);

            mContext = Utils.RequireContext();
            mOnAccept = onAccept;
            mPort = port;

            mAcceptEvent = new SocketAsyncEventArgs();
            mAcceptEvent.Completed += HandleAccept;

            mAcceptor = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            try { mAcceptor.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true); }
            catch (SocketException e)
            {
                if (e.NativeErrorCode != (int)SocketError.OperationNotSupported)
                    throw;
            }
            mAcceptor.Bind(endpoint);
            mAcceptor.Listen((int)SocketOptionName.MaxConnections);

            CoreEvents.Log.AcceptorStarted(mPort);

            // we always post the first accept event so it doesn't invoke the callback before we return from the ctor
            if (!mAcceptor.AcceptAsync(mAcceptEvent))
                HandleAccept(mAcceptor, mAcceptEvent);
        }

        public void Dispose()
        {
            CoreEvents.Log.AcceptorStopped(mPort);

            mAcceptor.Dispose();
            mAcceptEvent.Dispose();
        }

        public int Port
        {
            get { return mPort; }
        }

        private void HandleAccept(object sender, SocketAsyncEventArgs e)
        {
            mContext.Post(x => HandleAccept(), null);
        }

        private void HandleAccept()
        {
        repeat:
            if (mAcceptEvent.SocketError == SocketError.Success)
            {
                var socket = mAcceptEvent.AcceptSocket;
                mAcceptEvent.AcceptSocket = null;
                CoreEvents.Log.AcceptorAccept(mPort, socket);
                mOnAccept(socket);
                if (!mAcceptor.AcceptAsync(mAcceptEvent))
                    goto repeat;
            }
            else
            {
                CoreEvents.Log.AcceptorError(mPort, mAcceptEvent.SocketError);

                // something bad happened, stop accepting
                //Dispose();

                // HACK: FailFast will crash too fast for the above message to appear in the log
                ConsoleAccess.Flush();

                var delays = new List<Task>();
                delays.Add(Task.CompletedTask);

                FatalError?.Invoke(task => delays.Add(task));

                Task.WhenAll(delays).ContinueWith(x => Environment.Exit(0));
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace AppNamespace
{
    public abstract class UplinkBase : IDisposable, INetworkWriterTarget
    {
        private static int mNextLogId;

        private SynchronizationContext mContext;
        private UplinkProtocol mProtocol;
        private int mLogId;
        private bool mDisposed;

        private NetworkReaderSource mInputController;
        private NetworkWriterControl mOutputController;
        private MemoryStream mWriteBuffer = new MemoryStream();
        private byte[] mWriteFrame = new byte[1 << 10];
        private bool mShutdownNotificationPosted;
        private bool mPostedReadyForInput;

        protected UplinkBase()
        {
            mLogId = Interlocked.Increment(ref mNextLogId);
            CoreEvents.Log.UplinkConnected(this);

            mContext = Utils.RequireContext();
            mContext.OperationStarted();

            mOutputController = new NetworkWriterControl(this);
            mInputController = new NetworkReaderSource();
        }

        public void Dispose()
        {
            if (!mDisposed)
            {
                mDisposed = true;

                try
                {
                    HandleDispose();

                    // if these asserts fire then base.HandleDispose was not called
                    Utils.Assert(mInputController.IsDisposed);
                    Utils.Assert(mOutputController.IsDisposed);

                    // this should be last so the protocol implementation sees a properly disposed uplink
                    if (mProtocol != null)
                    {
                        mProtocol.DetachInternal();
                        mProtocol.Dispose();
                    }
                }
                catch (Exception ex)
                {
                    Utils.ReportException(ex, true);
                }

                mContext.OperationCompleted();
            }
        }

        protected virtual void HandleDispose()
        {
            mInputController.Dispose();
            mOutputController.Dispose();
        }

        public bool IsDisposed
        {
            get { return mDisposed; }
        }

        public SynchronizationContext Context
        {
            get { return mContext; }
        }

        public int LogId
        {
            get { return mLogId; }
        }

        public UplinkProtocol SetProtocol(UplinkProtocol protocol, bool disposeOldProtocol)
        {
            if (mProtocol == protocol)
                return null;

            var oldProtocol = mProtocol;
            if (oldProtocol != null)
            {
                mProtocol = null;
                oldProtocol.DetachInternal();

                if (disposeOldProtocol)
                {
                    oldProtocol.Dispose();
                    oldProtocol = null;
                }
            }

            if (protocol != null)
            {
                mProtocol = protocol;
                protocol.AttachInternal(this);
                ReadyForInput();
            }

            return oldProtocol;
        }

        public NetworkWriter Write()
        {
            return mOutputController.Write();
        }

        public void Close(bool hard)
        {
            NotifyShutdown();
        }

        private void NotifyShutdown()
        {
            if (!mDisposed && !mShutdownNotificationPosted)
            {
                mShutdownNotificationPosted = true;
                mContext.OperationStarted();
                mContext.Post(x => ((UplinkBase)x).HandleShutdown(), this);
            }
        }

        private void HandleShutdown()
        {
            if (!mDisposed)
            {
                mInputController.SetComplete();
                using (var p = mInputController.Read())
                {
                    try { mProtocol.ProcessInputInternal(p); }
                    catch (ProtocolException ex)
                    {
                        CoreEvents.Log.UplinkProtocolException(mLogId, ex);
                        Dispose();
                    }
                }
            }

            mContext.OperationCompleted();
        }

        protected void AppendInput(byte[] buffer, int offset, int length)
        {
            CoreEvents.Log.UplinkReceivedData(LogId, length);
            CoreEvents.Log.UplinkReceivedDataPayload(LogId, buffer, 0, length);
            mInputController.Append(buffer, 0, length);
        }

        protected void CompleteInput()
        {
            CoreEvents.Log.UplinkRemoteShutdown(LogId);
            mInputController.SetComplete();
        }

        protected void ProcessInput()
        {
            if (!mPostedReadyForInput)
            {
                using (var p = mInputController.Read())
                {
                    try { mProtocol.ProcessInputInternal(p); }
                    catch (ProtocolException ex)
                    {
                        CoreEvents.Log.UplinkProtocolException(mLogId, ex);
                        Dispose();
                    }
                }
            }
        }

        #region Input

        public bool InputComplete
        {
            get { return mInputController.IsComplete; }
        }

        public int AvailableInput
        {
            get { return mInputController.Available; }
        }

        public void ReadyForInput()
        {
            if (!mPostedReadyForInput)
            {
                mPostedReadyForInput = true;
                mContext.OperationStarted();
                mContext.Post(ReadyForInputCallback, null);
            }
        }

        private void ReadyForInputCallback(object unused)
        {
            Utils.Assert(mPostedReadyForInput);
            mPostedReadyForInput = false;
            mContext.OperationCompleted();

            using (var p = mInputController.Read())
                mProtocol.ProcessInputInternal(p);
        }

        #endregion

        #region Output

        protected abstract void HandleSend(byte[] buffer, int offset, int length);

        public void BeginOutput()
        {
        }

        public ArraySegment<byte> RequestOutputPage(int sizeHint)
        {
            return new ArraySegment<byte>(mWriteFrame);
        }

        public void SubmitOutputPage(ArraySegment<byte> data)
        {
            mWriteBuffer.Write(data.Array, data.Offset, data.Count);
        }

        public void SuspendOutput()
        {
        }

        public void FlushOutput()
        {
            var buffer = mWriteBuffer.ToArray();
            HandleSend(buffer, 0, buffer.Length);
            mWriteBuffer.SetLength(0);
        }

        #endregion

        #region INetworkWriterTarget Members

        void INetworkWriterTarget.Begin()
        {
            BeginOutput();
        }

        void INetworkWriterTarget.Submit(ArraySegment<byte> data)
        {
            SubmitOutputPage(data);
        }

        void INetworkWriterTarget.Complete()
        {
            SuspendOutput();
        }

        #endregion  }
    }

    public sealed class SocketUplink : UplinkBase
    {
        public static SocketUplink Connect(IPEndPoint endpoint)
        {
            var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            socket.Connect(endpoint);
            return new SocketUplink(socket);
        }

        private Socket mSocket;
        private IPEndPoint mRemote;
        private SocketAsyncEventArgs mRecvEvent;
        private byte[] mInputBuffer;
        private SocketAsyncEventArgs mSendEvent;
        private List<ArraySegment<byte>> mSendData;
        private bool mSendActive;

        public SocketUplink(Socket socket)
        {
            if ((mSocket = socket) == null)
                throw new ArgumentNullException("socket");

            mRemote = (IPEndPoint)mSocket.RemoteEndPoint;

            mSendEvent = new SocketAsyncEventArgs();
            mSendEvent.Completed += HandleSendComplete;

            mRecvEvent = new SocketAsyncEventArgs();
            mRecvEvent.Completed += HandleRecvComplete;

            mInputBuffer = new byte[1 << 10];
            mRecvEvent.SetBuffer(mInputBuffer, 0, mInputBuffer.Length);

            Context.OperationStarted();
            if (!mSocket.ReceiveAsync(mRecvEvent))
                Context.Post(x => ((SocketUplink)x).HandleRecvComplete(), this);
        }

        public override string ToString()
        {
            return StringNC.Format("{{SocketUplink Id={0}, Remote={1}}}", LogId, mRemote);
        }

        protected override void HandleDispose()
        {
            mSocket.Dispose();
            mRecvEvent.Dispose();
            mSendEvent.Dispose();
            base.HandleDispose();
        }

        public IPEndPoint RemoteEndpoint
        {
            get { return mRemote; }
        }

        private void HandleRecvComplete(object sender, SocketAsyncEventArgs e)
        {
            Context.Post(x => ((SocketUplink)x).HandleRecvComplete(), this);
        }

        private void HandleRecvComplete()
        {
            bool process = false;

        repeat:
            Context.OperationCompleted();

            if (mRecvEvent.SocketError == SocketError.Success)
            {
                process = true;
                int length = mRecvEvent.BytesTransferred;
                if (length == 0)
                {
                    CompleteInput();
                }
                else
                {
                    AppendInput(mInputBuffer, 0, length);
                    mRecvEvent.SetBuffer(mInputBuffer, 0, mInputBuffer.Length);

                    Context.OperationStarted();
                    if (!mSocket.ReceiveAsync(mRecvEvent))
                        goto repeat;
                }
            }
            else
            {
                process = false;
                CoreEvents.Log.UplinkError(LogId, mRecvEvent.SocketError);
                Dispose();
            }

            if (process)
                ProcessInput();
        }

        protected override void HandleSend(byte[] buffer, int offset, int length)
        {
            try
            {
                if (mSendData == null)
                    mSendData = new List<ArraySegment<byte>>();

                mSendData.Add(new ArraySegment<byte>(buffer, offset, length));

                if (!mSendActive)
                {
                    mSendEvent.BufferList = mSendData;
                    mSendData = null;
                    mSendActive = true;

                    Context.OperationStarted();
                    if (!mSocket.SendAsync(mSendEvent))
                        HandleSendComplete();
                }
            }
            catch (SocketException ex)
            {
                CoreEvents.Log.UplinkError(LogId, ex.SocketErrorCode);
                Dispose();
            }
        }

        private void HandleSendComplete(object sender, SocketAsyncEventArgs e)
        {
            Context.Post(x => ((SocketUplink)x).HandleSendComplete(), this);
        }

        private void HandleSendComplete()
        {
        repeat:
            Context.OperationCompleted();
            mSendActive = false;

            if (mSendEvent.SocketError != SocketError.Success)
            {
                CoreEvents.Log.UplinkError(LogId, mSendEvent.SocketError);
                Dispose();
                return;
            }

            if (mSendData != null && mSendData.Count > 0)
            {
                mSendEvent.BufferList = mSendData;
                mSendData = null;
                mSendActive = true;

                Context.OperationStarted();
                if (!mSocket.SendAsync(mSendEvent))
                    goto repeat;
            }
        }
    }
}