RFC 1981

Path MTU Discovery for IP version 6

📅 published August 1996, from ietf

RFC 1981: Path MTU Discovery for IP version 6 🦋

Okay bestie, this is RFC 1981, called Path MTU Discovery for IP version 6 💖 It's a Standards Track doc from August 1996, so it's on the official standards path and not just vibes 💅 The authors are J. McCann (Digital Equipment Corporation), S. Deering (Xerox PARC), and J. Mogul (Digital Equipment Corporation) 👑 It came out of the Network Working Group, and the header doesn't list anything it obsoletes or updates ✨

Status of This Memo 📜

This doc specifies an Internet standards track protocol for the Internet community, and it asks for discussion and suggestions for improvements 🌸 For the standardization state and status of this protocol, check the current edition of the "Internet Official Protocol Standards" (STD 1) 🧚 Distribution of this memo is unlimited 🫶

Abstract 🍓

This doc describes Path MTU Discovery for IP version 6 💜 It's largely derived from RFC 1191, which describes Path MTU Discovery for IP version 4 ✨

Table of Contents 🗂️

   1. Introduction.................................................2
   2. Terminology..................................................2
   3. Protocol overview............................................3
   4. Protocol Requirements........................................4
   5. Implementation Issues........................................5
   5.1. Layering...................................................5
   5.2. Storing PMTU information...................................6
   5.3. Purging stale PMTU information.............................8
   5.4. TCP layer actions..........................................9
   5.5. Issues for other transport protocols......................11
   5.6. Management interface......................................12
   6. Security Considerations.....................................12
   Acknowledgements...............................................13
   Appendix A - Comparison to RFC 1191............................14
   References.....................................................14
   Authors' Addresses.............................................15

1. Introduction 🌈

Okay so when one IPv6 node has a huge pile of data to send to another node, it gets sent as a bunch of IPv6 packets 📦 It's usually best if those packets are the biggest size that can successfully make it from the source node to the destination node. That size is called the Path MTU (PMTU), and it's equal to the minimum link MTU of all the links in a path 🔍 IPv6 has a standard mechanism for a node to discover the PMTU of any path, which is honestly iconic.

IPv6 nodes SHOULD implement Path MTU Discovery so they can find and take advantage of paths with a PMTU greater than the IPv6 minimum link MTU [IPv6-SPEC] 💖 A minimal IPv6 implementation (e.g., in a boot ROM) may choose to omit implementation of Path MTU Discovery 🧚

Nodes that don't implement Path MTU Discovery just use the IPv6 minimum link MTU defined in [IPv6-SPEC] as their maximum packet size 😬 In most cases that means smaller packets than necessary, because most paths have a PMTU bigger than the IPv6 minimum link MTU 💀 A node sending packets way smaller than the Path MTU allows is wasting network resources and probably getting suboptimal throughput 🙈

2. Terminology 📖

node: a device that implements IPv6.
router: a node that forwards IPv6 packets not explicitly addressed to itself.
host: any node that is not a router.
upper layer: a protocol layer immediately above IPv6. Examples are transport protocols such as TCP and UDP, control protocols such as ICMP, routing protocols such as OSPF, and internet or lower-layer protocols being "tunneled" over (i.e., encapsulated in) IPv6 such as IPX, AppleTalk, or IPv6 itself.
link: a communication facility or medium over which nodes can communicate at the link layer, i.e., the layer immediately below IPv6. Examples are Ethernets (simple or bridged), PPP links, X.25, Frame Relay, or ATM networks, and internet (or higher) layer "tunnels", such as tunnels over IPv4 or IPv6 itself.
interface: a node's attachment to a link.
address: an IPv6-layer identifier for an interface or a set of interfaces.
packet: an IPv6 header plus payload.
link MTU: the maximum transmission unit, i.e., maximum packet size in octets, that can be conveyed in one piece over a link.
path: the set of links traversed by a packet between a source node and a destination node.
path MTU: the minimum link MTU of all the links in a path between a source node and a destination node.
PMTU: path MTU.
Path MTU Discovery: the process by which a node learns the PMTU of a path.
flow: a sequence of packets sent from a particular source to a particular (unicast or multicast) destination for which the source desires special handling by the intervening routers.
flow id: a combination of a source address and a non-zero flow label.

3. Protocol overview 🛸

This memo describes a technique to dynamically discover the PMTU of a path 🔭 The basic idea is that a source node starts out assuming the PMTU of a path is the (known) MTU of the first hop in that path. If any packets sent on that path are too large to be forwarded by some node along the way, that node discards them and sends back ICMPv6 Packet Too Big messages [ICMPv6] 💌 When the source gets one, it reduces its assumed PMTU for the path based on the MTU of the constricting hop, as reported in the Packet Too Big message.

The Path MTU Discovery process ends when the node's estimate of the PMTU is less than or equal to the actual PMTU. Note that several iterations of the packet-sent/Packet-Too-Big-message-received cycle may occur before the process ends, since there may be links with smaller MTUs further along the path 🔁

Alternatively, the node may elect to end the discovery process by ceasing to send packets larger than the IPv6 minimum link MTU.

The PMTU of a path may change over time due to changes in the routing topology. Reductions of the PMTU are detected by Packet Too Big messages. To detect increases in a path's PMTU, a node periodically increases its assumed PMTU. This will almost always result in packets being discarded and Packet Too Big messages being generated, because in most cases the PMTU of the path will not have changed. Therefore, attempts to detect increases in a path's PMTU should be done infrequently 🐢

Path MTU Discovery supports multicast as well as unicast destinations 🌍 With a multicast destination, copies of a packet may traverse many different paths to many different nodes. Each path may have a different PMTU, so a single multicast packet may result in multiple Packet Too Big messages, each reporting a different next-hop MTU. The minimum PMTU value across the set of paths in use determines the size of subsequent packets sent to the multicast destination.

Note that Path MTU Discovery must be performed even when a node "thinks" a destination is attached to the same link as itself 👀 For example, a neighboring router might act as proxy [ND] for some destination. The destination can appear to be directly connected but is in fact more than one hop away.

4. Protocol Requirements 📋

As discussed in section 1, IPv6 nodes are not required to implement Path MTU Discovery 🫶 The requirements in this section only apply to those implementations that include Path MTU Discovery.

When a node receives a Packet Too Big message, it MUST reduce its estimate of the PMTU for the relevant path, based on the value of the MTU field in the message. The precise behavior of a node in this circumstance is not specified, since different applications may have different requirements, and different implementation architectures may favor different strategies 🧠

After receiving a Packet Too Big message, a node MUST attempt to avoid eliciting more such messages in the near future. The node MUST reduce the size of the packets it is sending along the path. Using a PMTU estimate larger than the IPv6 minimum link MTU may continue to elicit Packet Too Big messages. Since each of these messages (and the dropped packets they respond to) consume network resources, the node MUST force the Path MTU Discovery process to end 🛑

Nodes using Path MTU Discovery MUST detect decreases in PMTU as fast as possible ⚡ Nodes MAY detect increases in PMTU. Doing so requires sending packets larger than the current estimated PMTU, and the likelihood is that the PMTU will not have increased, so this MUST be done at infrequent intervals. An attempt to detect an increase (by sending a packet larger than the current estimate) MUST NOT be done less than 5 minutes after a Packet Too Big message has been received for the given path ⏳ The recommended setting for this timer is twice its minimum value (10 minutes).

A node MUST NOT reduce its estimate of the Path MTU below the IPv6 minimum link MTU 🚫

Note: A node may receive a Packet Too Big message reporting a next-hop MTU that is less than the IPv6 minimum link MTU. In that case, the node is not required to reduce the size of subsequent packets sent on the path to less than the IPv6 minimum link MTU, but rather must include a Fragment header in those packets [IPv6-SPEC] 🧩

A node MUST NOT increase its estimate of the Path MTU in response to the contents of a Packet Too Big message 🙅 A message that seems to announce an increase in the Path MTU might be a stale packet that has been floating around the network, a false packet injected as part of a denial-of-service attack, or the result of having multiple paths to the destination, each with a different PMTU. Not trusting it is the move 💀

5. Implementation Issues 🔧

This section discusses a number of issues related to the implementation of Path MTU Discovery. This is not a specification, but rather a set of notes provided as an aid for implementors 📝

The issues include:

What layer or layers implement Path MTU Discovery?
How is the PMTU information cached?
How is stale PMTU information removed?
What must transport and higher layers do?

5.1. Layering ✨

Okay so in IP land, the choice of how big a packet to send gets made by a protocol sitting above IP 📦. This memo calls that a "packetization protocol". Packetization protocols are usually transport protocols (like TCP), but they can also be higher-layer protocols (like stuff built on top of UDP).

Doing Path MTU Discovery inside the packetization layers simplifies some inter-layer drama 🙄, but it has real downsides. You might have to redo the work for every packetization protocol, sharing PMTU info between layers gets messy, and the connection-oriented state some layers keep may not easily stretch to save PMTU info for long periods.

So it's suggested that the IP layer stores PMTU info and the ICMP layer processes received Packet Too Big messages. The packetization layers can then respond to PMTU changes by changing the size of the messages they send. To make this layering work, packetization layers need a way to learn about changes in MMS_S, the "maximum send transport-message size" 💅. MMS_S is derived from the Path MTU by subtracting the size of the IPv6 header plus any space the IP layer reserves for additional headers (if any).

Now, it's possible that a packetization layer (maybe a UDP app running outside the kernel) can't change the size of the messages it sends 😬. That can produce a packet bigger than the Path MTU. For those situations, IPv6 has a mechanism that lets large payloads get divided into fragments, with each fragment sent in its own packet (see [IPv6-SPEC] section "Fragment Header"). However, packetization layers are encouraged to avoid sending messages that will need fragmentation (for the case against fragmentation, see [FRAG]) 🫶.

5.2. Storing PMTU information 🧚

Ideally, a PMTU value would be tied to one specific path that packets take between the source and destination nodes. But honestly, in most cases a node won't have enough info to fully and accurately identify that path 🥺. So instead, a node has to tie a PMTU value to some local representation of a path, and it's left up to the implementation to pick that representation.

For a multicast destination address, copies of a packet might travel many different paths to reach many different nodes. So the local representation of the "path" to a multicast destination has to stand in for a potentially large set of paths 🌈.

The minimum option is for an implementation to keep one single PMTU value for every packet the node originates. That value would be the smallest PMTU learned across all the paths the node uses. Tbh this tends to produce smaller packets than necessary for lots of paths 😭.

An implementation could also use the destination address as the local representation of a path. The PMTU value for a destination would then be the smallest PMTU learned across all the paths used to reach that destination. The set of paths in use to one destination is expected to be small, often just a single path. This gives optimally sized packets on a per-destination basis 💖. It also fits nicely with the conceptual model of a host described in [ND]: a PMTU value could be stored right alongside the matching entry in the destination cache ✨.

If flows [IPv6-SPEC] are in use, an implementation could use the flow id as the local representation of a path. Packets sent to the same destination but belonging to different flows may take different paths, depending on the flow id 🦋. This gives optimally sized packets on a per-flow basis, which is finer-grained than per-destination PMTU values.

For source routed packets (that is, packets containing an IPv6 Routing header [IPv6-SPEC]), the source route can further qualify the local representation of a path. In particular, a packet containing a type 0 Routing header where every bit in the Strict/Loose Bit Map is equal to 1 contains a complete path specification 👑. An implementation could use source route info as part of the local representation of a path.

Note: Some paths may be further distinguished by different security classifications. The details of such classifications are beyond the scope of this memo.

At first, the PMTU value for a path is assumed to be the (known) MTU of the first-hop link 🍓.

When a Packet Too Big message arrives, the node figures out which path the message applies to based on the contents of that message 🔍. For example, if the destination address is used as the local representation of a path, the destination address from the original packet is what tells the node which path the message applies to.

Note: If the original packet contained a Routing header, the Routing header should be used to find where the destination address sits within the original packet. If Segments Left is equal to zero, the destination address is in the Destination Address field of the IPv6 header. If Segments Left is greater than zero, the destination address is the last address (Address[n]) in the Routing header.

Next, the node takes the value in the MTU field of the Packet Too Big message as a tentative PMTU value and compares it to the existing PMTU. If the tentative PMTU is less than the existing PMTU estimate, the tentative PMTU replaces the existing one as the PMTU value for the path 🔥.

The packetization layers must be notified about decreases in the PMTU 🚨. Any packetization layer instance (for example, a TCP connection) that is actively using the path must be notified if the PMTU estimate goes down.

Note: Even if the Packet Too Big message contains an Original Packet Header that refers to a UDP packet, the TCP layer must be notified if any of its connections use the given path 👀.

Also, the instance that sent the packet that triggered the Packet Too Big message should be notified that its packet got dropped. This is true even if the PMTU estimate hasn't changed, so that it can retransmit the dropped data 🔁.

Note: An implementation can skip an asynchronous notification mechanism for PMTU decreases by postponing the notification until the next attempt to send a packet larger than the PMTU estimate. In this approach, when an attempt is made to SEND a packet larger than the PMTU estimate, the SEND function should fail and return a suitable error indication. This approach may be more suitable to a connectionless packetization layer (such as one using UDP), which (in some implementations) may be hard to "notify" from the ICMP layer 🙃. In this case, the normal timeout-based retransmission mechanisms would be used to recover from the dropped packets.

It's super important to understand that notifying the packetization layer instances using the path about a PMTU change is a different thing from notifying a specific instance that a packet got dropped 🧐. The second one should happen as soon as practical (that is, asynchronously from the point of view of the packetization layer instance). The first one may be delayed until a packetization layer instance wants to create a packet. Retransmission should be done for only those packets that are known to be dropped, as indicated by a Packet Too Big message 💜.

5.3. Purging stale PMTU information 🕰️

Internetwork topology is dynamic, and routes change over time 🌊. While the local representation of a path may stay constant, the actual path(s) in use may change. So PMTU info cached by a node can get stale.

If a stale PMTU value is too large, that gets discovered almost right away once a big enough packet is sent on the path. But there's no such mechanism for realizing that a stale PMTU value is too small 😤. So an implementation should "age" cached values. When a PMTU value hasn't been decreased for a while (on the order of 10 minutes), the PMTU estimate should be set to the MTU of the first-hop link, and the packetization layers should be notified of the change. This makes the complete Path MTU Discovery process run again ✨.

Note: An implementation should provide a means for changing the timeout duration, including setting it to "infinity". For example, nodes attached to an FDDI link, which is then attached to the rest of the Internet via a small MTU serial line, are never going to discover a new non-local PMTU. So they shouldn't have to put up with dropped packets every 10 minutes 🥲.

An upper layer must not retransmit data in response to an increase in the PMTU estimate, since that increase never comes in response to an indication of a dropped packet 🚫.

One approach to implementing PMTU aging is to associate a timestamp field with a PMTU value 🕒. This field is initialized to a "reserved" value, which indicates that the PMTU is equal to the MTU of the first-hop link. Whenever the PMTU is decreased in response to a Packet Too Big message, the timestamp is set to the current time.

Once a minute, a timer-driven procedure runs through all cached PMTU values. For each PMTU whose timestamp is not "reserved" and is older than the timeout interval:

The PMTU estimate is set to the MTU of the first-hop link. 🏠
The timestamp is set to the "reserved" value. 🔄
Packetization layers using this path are notified of the increase. 📣

5.4. TCP layer actions ✨

okay so the TCP layer must keep track of the PMTU for whatever path(s) a connection is using 🛣️, and it should not send segments that would end up making packets bigger than the PMTU 🙅‍♀️. a simple version could ask the IP layer for that number every single time it builds a new segment, but ngl that could be super inefficient 🥴. also, TCP implementations that use the "slow-start" congestion-avoidance algorithm [CONG] usually work out and cache a bunch of other values that come from the PMTU. so it may be simpler to get an asynchronous notification when the PMTU changes, so those variables can get updated 💅✨.

bestie, a TCP implementation must also store the MSS value it gets from its peer, and it must never send any segment bigger than that MSS, no matter what the PMTU is 🫶. in 4.xBSD-derived implementations, this might mean adding an extra field to the TCP state record 🧚.

the value you put in the TCP MSS option has nothing to do with the PMTU 🙅. the other end of the connection uses that value, and it might be running with a totally unrelated PMTU 🤷. if you want to know how to pick that value, the "Packet Size Issues" and "Maximum Upper-Layer Payload Size" sections of [IPv6-SPEC] are where that info lives 📖.

when a Packet Too Big message shows up, it means a packet got dropped by the node that sent that ICMP message 😬. treating it like any other dropped segment is enough, so you just wait for the retransmission timer to go off and resend the segment. but if Path MTU Discovery needs a bunch of steps to find the PMTU of the whole path, that wait could hold the connection up for many round-trip times 🐢.

another option is retransmitting right away when the Path MTU changes, but only for the one connection that the Packet Too Big message is about ⚡. whatever size you use for that retransmission should be no bigger than the new PMTU 📏.

🚨 Note: a packetization layer must not retransmit in response to every single Packet Too Big message, since a burst of several oversized segments will give rise to several of those messages, and therefore several retransmissions of the same data. if the new estimated PMTU is still wrong, the process repeats, and the number of superfluous segments sent grows exponentially 📈💀.

this means the TCP layer must be able to tell when a Packet Too Big notification actually lowers the PMTU it already used to send a packet on that connection, and it should ignore any other notifications 🧐.

lots of TCP implementations include "congestion avoidance" and "slow-start" algorithms to boost performance [CONG] 🚀. the difference is that a retransmission caused by a TCP retransmission timeout is not the same as one caused by a Packet Too Big message. the Packet Too Big kind should not change the congestion window 🪟. it should, however, kick off the slow-start mechanism, meaning only one segment gets retransmitted until acknowledgements start coming back again 🐣.

TCP performance can take a hit if the sender's maximum window size isn't an exact multiple of the segment size in use. (the congestion window is always a multiple of the segment size, so this is about the maximum window size, not that one 🙃.) in many systems, like those derived from 4.2BSD, the segment size is often set to 1024 octets, and the maximum window size (the "send space") is usually a multiple of 1024 octets, so the right relationship holds by default 🎀. with Path MTU Discovery, though, the segment size may stop being a submultiple of the send space, and it may change during a connection. that means the TCP layer may need to change the transmission window size whenever Path MTU Discovery changes the PMTU value 🔄. the maximum window size should be set to the greatest multiple of the segment size that's less than or equal to the sender's buffer space size 💖.

5.5. Issues for other transport protocols

some transport protocols, like ISO TP4 [ISOTP], aren't allowed to repacketize during a retransmission 🙅‍♀️. so once a segment of a certain size has been sent, the transport can't split its contents into smaller segments for retransmission. in that situation, the IP layer can fragment the original segment during retransmission 🧩. any subsequent segments that get sent for the first time should be no larger than the Path MTU allows 🦋.

the Sun Network File System (NFS) uses a Remote Procedure Call (RPC) protocol [RPC] 🗂️. over UDP, that RPC protocol often generates payloads that have to be fragmented, even on the first-hop link 😵. this might help performance in certain cases, but it's known to cause reliability and performance problems, especially when the client and server are separated by routers 🫠.

it is recommended that NFS implementations use Path MTU Discovery whenever routers are involved 🧭. most NFS implementations let you change the RPC datagram size at mount-time (indirectly, by changing the effective file system block size), but they might need some changes to support changing it later on 🛠️.

also, a single NFS operation can't be split across several UDP datagrams 📦. because of that, certain operations (mainly the ones working on file names and directories) need a minimum payload size that would exceed the PMTU if sent in one packet 😤. NFS implementations should not drop the payload size below that threshold, even if Path MTU Discovery suggests a lower value. when that happens, the IP layer will fragment the payload 🧩✨.

5.6. Management interface

it is suggested that an implementation give a system utility program a way to:

Specify that Path MTU Discovery not be done on a given path. 🚫
Change the PMTU value associated with a given path. 🔧

the first one can be done by attaching a flag to the path. when a packet goes out on a path with that flag set, the IP layer won't send packets bigger than the IPv6 minimum link MTU 🧱.

these features might come in clutch for working around an anomalous situation, or for a routing protocol implementation that's able to get Path MTU values 🦸‍♀️.

the implementation should also provide a way to change the timeout period for aging out stale PMTU information ⏳.

6. Security Considerations 🚨

this Path MTU Discovery mechanism opens up two denial-of-service attacks, and both of them work by a malicious party sending false Packet Too Big messages to a node 😈.

in the first attack, the fake message claims a PMTU way smaller than reality 📉. this shouldn't completely stop data from flowing, because the victim node should never set its PMTU estimate below the IPv6 minimum link MTU 🛡️. it will still mean suboptimal performance though 🐌.

in the second attack, the fake message claims a PMTU bigger than reality 📈. if the victim believes it, that could cause a temporary blockage, since the victim keeps sending packets that some router will drop 💀. within one round-trip time, the node would figure out its mistake, because it would receive Packet Too Big messages from that router. but if the attacker keeps repeating this, lots of packets could get dropped 😭. still, a node should never raise its estimate of the PMTU based on a Packet Too Big message, so it shouldn't be vulnerable to this attack 🫶.

a malicious party could also cause problems if it managed to stop a victim from receiving legitimate Packet Too Big messages. but in that case, there are simpler denial-of-service attacks available anyway 🙄.

Acknowledgements 🙏

we'd like to acknowledge the authors of and contributors to [RFC-1191], which the majority of this document was derived from 💜. we'd also like to acknowledge the members of the IPng working group for their careful review and constructive criticisms 🌸.

Appendix A - Comparison to RFC 1191 ✨

this document is based in large part on RFC 1191, which describes Path MTU Discovery for IPv4. some parts of RFC 1191 weren't needed here 🧐:

router specification    - Packet Too Big messages and corresponding
                          router behavior are defined in [ICMPv6]

Don't Fragment bit      - there is no DF bit in IPv6 packets

TCP MSS discussion      - selecting a value to send in the TCP MSS
                          option is discussed in [IPv6-SPEC]

old-style messages      - all Packet Too Big messages report the
                          MTU of the constricting link

MTU plateau tables      - not needed because there are no old-style
                          messages

References 📚

[CONG]      Van Jacobson.  Congestion Avoidance and Control.  Proc.
            SIGCOMM '88 Symposium on Communications Architectures and
            Protocols, pages 314-329.  Stanford, CA, August, 1988.

[FRAG]      C. Kent and J. Mogul.  Fragmentation Considered Harmful.
            In Proc. SIGCOMM '87 Workshop on Frontiers in Computer
            Communications Technology.  August, 1987.

[ICMPv6]    Conta, A., and S. Deering, "Internet Control Message
            Protocol (ICMPv6) for the Internet Protocol Version 6
            (IPv6) Specification", RFC 1885, December 1995.

[IPv6-SPEC] Deering, S., and R. Hinden, "Internet Protocol, Version
            6 (IPv6) Specification", RFC 1883, December 1995.

[ISOTP]     ISO.  ISO Transport Protocol Specification: ISO DP 8073.
            RFC 905, SRI Network Information Center, April, 1984.

[ND]        Narten, T., Nordmark, E., and W. Simpson, "Neighbor
            Discovery for IP Version 6 (IPv6)", Work in Progress.

[RFC-1191]  Mogul, J., and S. Deering, "Path MTU Discovery",
            RFC 1191, November 1990.

[RPC]       Sun Microsystems, Inc., "RPC: Remote Procedure Call
            Protocol", RFC 1057, SRI Network Information Center,
            June, 1988.

Authors' Addresses 💌

Jack McCann
Digital Equipment Corporation
110 Spitbrook Road, ZKO3-3/U14
Nashua, NH 03062
Phone: +1 603 881 2608

Fax:   +1 603 881 0120
Email: mccann@zk3.dec.com


Stephen E. Deering
Xerox Palo Alto Research Center
3333 Coyote Hill Road
Palo Alto, CA 94304
Phone: +1 415 812 4839

Fax:   +1 415 812 4471
EMail: deering@parc.xerox.com


Jeffrey Mogul
Digital Equipment Corporation Western Research Laboratory
250 University Avenue
Palo Alto, CA 94301
Phone: +1 415 617 3304

EMail: mogul@pa.dec.com

📦 where this page comes from

ietf: rfc1981 1996-08
💖 girlified by claude-haiku-5-5 on 2026-10-15: a language model's rewrite of the original, under its terms