tcp_stats = {
        # An application wasn't able to accept a connection fast enough, so
        # the kernel couldn't store an entry in the queue for this connection.
        # Instead of dropping it, it sent a cookie to the client.
        "SyncookiesSent": ("syncookies", "type=sent"),
        # After sending a cookie, it came back to us and passed the check.
        "SyncookiesRecv": ("syncookies", "type=received"),
        # After sending a cookie, it came back to us but looked invalid.
        "SyncookiesFailed": ("syncookies", "type=failed"),
        # When a socket is using too much memory (rmem), the kernel will first
        # discard any out-of-order packet that has been queued (with SACK).
        "OfoPruned": ("memory.prune", "type=drop_ofo_queue"),
        # If the kernel is really really desperate and cannot give more memory
        # to this socket even after dropping the ofo queue, it will simply
        # discard the packet it received.  This is Really Bad.
        "RcvPruned": ("memory.prune", "type=drop_received"),
        # We waited for another packet to send an ACK, but didn't see any, so
        # a timer ended up sending a delayed ACK.
        "DelayedACKs": ("delayedack", "type=sent"),
        # We wanted to send a delayed ACK but failed because the socket was
        # locked.  So the timer was reset.
        "DelayedACKLocked": ("delayedack", "type=locked"),
        # We sent a delayed and duplicated ACK because the remote peer
        # retransmitted a packet, thinking that it didn't get to us.
        "DelayedACKLost": ("delayedack", "type=lost"),
        # We completed a 3WHS but couldn't put the socket on the accept queue,
        # so we had to discard the connection.
        "ListenOverflows": ("failed_accept", "reason=full_acceptq"),
        # We couldn't accept a connection because one of: we had no route to
        # the destination, we failed to allocate a socket, we failed to
        # allocate a new local port bind bucket.  Note: this counter
        # also include all the increments made to ListenOverflows...
        "ListenDrops": ("failed_accept", "reason=other"),
        # A packet was lost and we used Forward RTO-Recovery to retransmit.
        "TCPForwardRetrans": ("retransmit", "type=forward"),
        # A packet was lost and we fast-retransmitted it.
        "TCPFastRetrans": ("retransmit", "type=fast"),
        # A packet was lost and we retransmitted after a slow start.
        "TCPSlowStartRetrans": ("retransmit", "type=slowstart"),
        # A packet was lost and we recovered after a fast retransmit.
        "TCPRenoRecovery": ("packetloss.recovery", "type=fast_retransmit"),
        # A packet was lost and we recovered by using selective
        # acknowledgements.
        "TCPSackRecovery": ("packetloss.recovery", "type=sack"),
        # We detected re-ordering using FACK (Forward ACK -- the highest
        # sequence number known to have been received by the peer when using
        # SACK -- FACK is used during congestion control).
        "TCPFACKReorder": ("reording", "detectedby=fack"),
        # We detected re-ordering using SACK.
        "TCPSACKReorder": ("reording", "detectedby=sack"),
        # We detected re-ordering using fast retransmit.
        "TCPRenoReorder": ("reording", "detectedby=fast_retransmit"),
        # We detected re-ordering using the timestamp option.
        "TCPTSReorder": ("reording", "detectedby=timestamp"),
        # We detected some erroneous retransmits and undid our CWND reduction.
        "TCPFullUndo": ("congestion.recovery", "type=full_undo"),
        # We detected some erroneous retransmits, a partial ACK arrived while
        # we were fast retransmitting, so we were able to partially undo some
        # of our CWND reduction.
        "TCPPartialUndo": ("congestion.recovery", "type=hoe_heuristic"),
        # We detected some erroneous retransmits, a D-SACK arrived and ACK'ed
        # all the retransmitted data, so we undid our CWND reduction.
        "TCPDSACKUndo": ("congestion.recovery", "type=sack"),
        # We detected some erroneous retransmits, a partial ACK arrived, so we
        # undid our CWND reduction.
        "TCPLossUndo": ("congestion.recovery", "type=ack"),
        # We received an unexpected SYN so we sent a RST to the peer.
        "TCPAbortOnSyn": ("abort", "type=unexpected_syn"),
        # We were in FIN_WAIT1 yet we received a data packet with a sequence
        # number that's beyond the last one for this connection, so we RST'ed.
        "TCPAbortOnData": ("abort", "type=data_after_fin_wait1"),
        # We received data but the user has closed the socket, so we have no
        # wait of handing it to them, so we RST'ed.
        "TCPAbortOnClose": ("abort", "type=data_after_close"),
        # This is Really Bad.  It happens when there are too many orphaned
        # sockets (not attached a FD) and the kernel has to drop a connection.
        # Sometimes it will send a reset to the peer, sometimes it wont.
        "TCPAbortOnMemory": ("abort", "type=out_of_memory"),
        # The connection timed out really hard.
        "TCPAbortOnTimeout": ("abort", "type=timeout"),
        # We killed a socket that was closed by the application and lingered
        # around for long enough.
        "TCPAbortOnLinger": ("abort", "type=linger"),
        # We tried to send a reset, probably during one of teh TCPABort*
        # situations above, but we failed e.g. because we couldn't allocate
        # enough memory (very bad).
        "TCPAbortFailed": ("abort.failed", None),
        # Number of times a socket was put in "memory pressure" due to a non
        # fatal memory allocation failure (reduces the send buffer size etc).
        "TCPMemoryPressures": ("memory.pressure", None),
        # We got a completely invalid SACK block and discarded it.
        "TCPSACKDiscard": ("invalid_sack", "type=invalid"),
        # We got a duplicate SACK while retransmitting so we discarded it.
        "TCPDSACKIgnoredOld": ("invalid_sack", "type=retransmit"),
        # We got a duplicate SACK and discarded it.
        "TCPDSACKIgnoredNoUndo": ("invalid_sack", "type=olddup"),
        # We received something but had to drop it because the socket's
        # receive queue was full.
        "TCPBacklogDrop": ("receive.queue.full", None),
    }
Copyright © opschina.org 2017 with zzlyzq@gmail.com all right reserved,powered by Gitbook该文件修订时间: 2017-07-11 11:32:48

results matching ""

    No results matching ""