F_SETLEASE mess
Al Viro
maintainer generic_add_lease() with F_WRLCK checks for other openers
in a very crude way - it wants no extra references to dentry (thus excluding other struct file pointing to it) *and* no extra references to in-core inode, excluding openers of other links. It fails with EAGAIN if those conditions are not met.
The way it deals with another open(2) racing with it (i.e.
managing to squeeze between the check and locks_insert_lock()) is theoretically racy; do_dentry_open() would spin on ->i_lock, all right, but... only if there already is something in inode->i_flock. If this is the first lease/lock being set, break_lease() will do nothing, rather than call __break_lease() and spin there.
It's _very_ hard to hit; we are holding ->i_lock and thus can't
be preempted, so open(2) would have to get *everything* (pathname lookup, etc.) done in a very narrow window. So I don't believe it's exploitable, but it really smells bad. The check is extremely crude and if nothing else it's a DoS fodder - a luser that keeps hitting that file with stat(2) can prevent F_SETLEASE from succeeding, even though he wouldn't be able to open the damn thing at all...
Quoted 13 lines · Al Viro
generic_add_lease()withF_WRLCKchecks for other openers
in a very crude way - it wants no extra references to dentry (thus excluding other struct file pointing to it) *and* no extra references to in-core inode, excluding openers of other links. It fails with EAGAIN if those conditions are not met.The way it deals with another open(2) racing with it (i.e.
managing to squeeze between the check andlocks_insert_lock()) is theoretically racy;do_dentry_open()would spin on ->i_lock, all right, but... only if there already is something ininode->i_flock. If this is the first lease/lock being set,break_lease()will do nothing, rather than call__break_lease()and spin there.
Quoted 7 lines
It's _very_ hard to hit; we are holding ->i_lock and thus can'tbe preempted, so open(2) would have to get *everything* (pathname lookup, etc.) done in a very narrow window. So I don't believe it's exploitable, but it really smells bad. The check is extremely crude and if nothing else it's a DoS fodder - a luser that keeps hitting that file with stat(2) can prevent
F_SETLEASEfrom succeeding, even though he wouldn't be able to open the damn thing at all...
(cc'ing Bruce since he's been poking around in this area recently and might have ideas...)
I see what you mean. I haven't looked closely at this yet, and I'm on holiday today, but I'll plan to give this more scrutiny when I get back next week. Giving it an initial look though...
We already hold an extra reference to the dentry via the path_get in do_dentry_open. So is this race possible if the two tasks are working on the same dentry? Or does it require a hardlinked inode?
If it's not possible to race on the same dentry, then one possible fix would be to go ahead and do an extra igrab(inode) in do_dentry_open before calling break_lease. I'm not particularly fond of that since it means taking the i_lock an extra time, but it looks like it would close the race.
Signature · 1 line
Jeff Layton <[email protected]>
Quoted 33 lines · Jeff Layton
Quoted 13 lines · Al Viro
generic_add_lease()withF_WRLCKchecks for other openers
in a very crude way - it wants no extra references to dentry (thus excluding other struct file pointing to it) *and* no extra references to in-core inode, excluding openers of other links. It fails with EAGAIN if those conditions are not met.The way it deals with another open(2) racing with it (i.e.
managing to squeeze between the check andlocks_insert_lock()) is theoretically racy;do_dentry_open()would spin on ->i_lock, all right, but... only if there already is something ininode->i_flock. If this is the first lease/lock being set,break_lease()will do nothing, rather than call__break_lease()and spin there.Quoted 7 lines
It's _very_ hard to hit; we are holding ->i_lock and thus can'tbe preempted, so open(2) would have to get *everything* (pathname lookup, etc.) done in a very narrow window. So I don't believe it's exploitable, but it really smells bad. The check is extremely crude and if nothing else it's a DoS fodder - a luser that keeps hitting that file with stat(2) can prevent
F_SETLEASEfrom succeeding, even though he wouldn't be able to open the damn thing at all...(cc'ing Bruce since he's been poking around in this area recently and might have ideas...)
I see what you mean. I haven't looked closely at this yet, and I'm on holiday today, but I'll plan to give this more scrutiny when I get back next week. Giving it an initial look though...
We already hold an extra reference to the dentry via the
path_getindo_dentry_open. So is this race possible if the two tasks are working on the same dentry? Or does it require a hardlinked inode?
Quoted 6 lines
If it's not possible to race on the same dentry, then one possible fix would be to go ahead and do an extra igrab(inode) in
do_dentry_openbefore callingbreak_lease. I'm not particularly fond of that since it means taking thei_lockan extra time, but it looks like it would close the race.
Hrm. I think we'd also need to couple that with an extra check for a high refcount after doing locks_insert_lock in generic_add_lease, and then call locks_delete_lock and return -EAGAIN if the counts have changed.
Signature · 1 line
Jeff Layton <[email protected]>
Quoted 14 lines
Quoted 14 lines · Al Viro
Quoted 13 lines
generic_add_lease()withF_WRLCKchecks for other openers
in a very crude way - it wants no extra references to dentry (thus excluding other struct file pointing to it) *and* no extra references to in-core inode, excluding openers of other links. It fails with EAGAIN if those conditions are not met.The way it deals with another open(2) racing with it (i.e.
managing to squeeze between the check andlocks_insert_lock()) is theoretically racy;do_dentry_open()would spin on ->i_lock, all right, but... only if there already is something ininode->i_flock. If this is the first lease/lock being set,break_lease()will do nothing, rather than call__break_lease()and spin there.
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
It's _very_ hard to hit; we are holding ->i_lock and thus can'tbe preempted, so open(2) would have to get *everything* (pathname lookup, etc.) done in a very narrow window. So I don't believe it's exploitable, but it really smells bad. The check is extremely crude and if nothing else it's a DoS fodder - a luser that keeps hitting that file with stat(2) can prevent
F_SETLEASEfrom succeeding, even though he wouldn't be able to open the damn thing at all...
nfsd isn't using write leases yet (I want to get read delegations sorted out first), and I don't understand Samba's requirements for write leases.
In the future, when nfsd does write delegations: they're an optional optimization, and if we're concerned about such a DOS one solution might be just to change everything to a trylock when acquiring delegations:
it's always acceptable to just fail the delegation.
Quoted 4 lines · Jeff Layton
Quoted 3 lines · Jeff Layton
We already hold an extra reference to the dentry via the
path_getindo_dentry_open. So is this race possible if the two tasks are working on the same dentry?
Well, as Al says, the race is roughly:
take i_lock
generic_add_lease checks d_count, i_count
Conflicting opener does "*everything* (pathname lookup, etc.)" (including that path_get, and breake_lease() (which sees no lock, so doesn't try to get i_lock.))
...
locks_insert_lock() adds new lock.
Quoted 4 lines
Quoted 4 lines
Or does it require a hardlinked inode?
If it's not possible to race on the same dentry, then one possible fix would be to go ahead and do an extra igrab(inode)
I think the only reason for this race is the attempt to optimize out an i_lock acquisition in break_lease. If we're willing to call igrab (which also takes the i_lock), then we may as well just take the i_lock.
Quoted 9 lines
Quoted 4 lines
in
do_dentry_open
before callingbreak_lease. I'm not particularly fond of that since it means taking thei_lockan extra time, but it looks like it would close the race.Hrm. I think we'd also need to couple that with an extra check for a high refcount after doing
locks_insert_lockingeneric_add_lease, and then calllocks_delete_lockand return-EAGAINif the counts have changed.
... but checking the counts again afterwards might work. (Dumb
question: in the absence of a lock on the opener's side, are the memory accesses ordered such that a lease-setter is guaranteed to see the new counts from an opener that didn't see the new i_flock value?)
How important is the optimization that skips the i_lock in break_lease?
--b.
Quoted 22 lines · Bruce Fields
Quoted 14 lines
Quoted 14 lines · Al Viro
Quoted 13 lines
generic_add_lease()withF_WRLCKchecks for other openers
in a very crude way - it wants no extra references to dentry (thus excluding other struct file pointing to it) *and* no extra references to in-core inode, excluding openers of other links. It fails with EAGAIN if those conditions are not met.The way it deals with another open(2) racing with it (i.e.
managing to squeeze between the check andlocks_insert_lock()) is theoretically racy;do_dentry_open()would spin on ->i_lock, all right, but... only if there already is something ininode->i_flock. If this is the first lease/lock being set,break_lease()will do nothing, rather than call__break_lease()and spin there.Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
It's _very_ hard to hit; we are holding ->i_lock and thus can'tbe preempted, so open(2) would have to get *everything* (pathname lookup, etc.) done in a very narrow window. So I don't believe it's exploitable, but it really smells bad. The check is extremely crude and if nothing else it's a DoS fodder - a luser that keeps hitting that file with stat(2) can prevent
F_SETLEASEfrom succeeding, even though he wouldn't be able to open the damn thing at all...
Quoted 9 lines
nfsd isn't using write leases yet (I want to get read delegations sorted out first), and I don't understand Samba's requirements for write leases.
In the future, when nfsd does write delegations: they're an optional optimization, and if we're concerned about such a DOS one solution might be just to change everything to a trylock when acquiring delegations:
it's always acceptable to just fail the delegation.
I think that's the case for Samba too. Oplocks are very similar to delegations, though there are of course some semantic differences.
Quoted 11 lines · Jeff Layton
Quoted 4 lines · Jeff Layton
Quoted 3 lines
We already hold an extra reference to the dentry via the
path_getindo_dentry_open. So is this race possible if the two tasks are working on the same dentry?Well, as Al says, the race is roughly:
take
i_lock
generic_add_leasechecksd_count,i_count
Quoted 7 lines
Conflicting opener does "*everything* (pathname lookup, etc.)" (including that
path_get, andbreake_lease()(which sees no lock, so doesn't try to geti_lock.))...
locks_insert_lock()adds new lock.
Right, I realized that while I was driving earlier. This race is definitely possible in either case...
Quoted 9 lines
Quoted 4 lines
Quoted 4 lines
Or does it require a hardlinked inode?
If it's not possible to race on the same dentry, then one possible fix would be to go ahead and do an extra igrab(inode)
I think the only reason for this race is the attempt to optimize out an
i_lockacquisition inbreak_lease. If we're willing to call igrab (which also takes thei_lock), then we may as well just take thei_lock.
I had misremembered the function name -- I had meant ihold/iput (which would commonly be lockless).
The point is moot though since we have a similar problem in the "same dentry" case anyway. Also the path_get on the other dentry would ensure that you had a i_count > 1...
So...disregard my silly rumbling about it. :)
Quoted 10 lines
Quoted 9 lines
Quoted 4 lines
in
do_dentry_open
before callingbreak_lease. I'm not particularly fond of that since it means taking thei_lockan extra time, but it looks like it would close the race.Hrm. I think we'd also need to couple that with an extra check for a high refcount after doing
locks_insert_lockingeneric_add_lease, and then calllocks_delete_lockand return-EAGAINif the counts have changed.
Quoted 5 lines
... but checking the counts again afterwards might work. (Dumb
question: in the absence of a lock on the opener's side, are the memory accesses ordered such that a lease-setter is guaranteed to see the new counts from an opener that didn't see the newi_flockvalue?)
I'm not sure. We'd certainly need to audit that and ensure that the lease setter does see them before we could rely on such a scheme.
Quoted 1 line
How important is the optimization that skips the
i_lockinbreak_lease?
Again, not sure...but I do shy away a bit from anything that would slow down opens in the case where leases aren't involved. I'd prefer any penalty be paid by the setlease caller. Opens are much more common than leases in almost every workload I can think of.
I think the bigger issue though is that looking at refcounts in order to determine when we have a conflicting open is just plain wrong. There are all sorts of reasons one might see a raised refcount that don't involve conflicting opens (Al's stat() example for instance). It seems like we ought to shoot for a solution that doesn't rely (solely) on inode and dentry refcounts.
Signature · 1 line
Jeff Layton <[email protected]>
Quoted 6 lines · Jeff Layton
I think the bigger issue though is that looking at refcounts in order to determine when we have a conflicting open is just plain wrong. There are all sorts of reasons one might see a raised refcount that don't involve conflicting opens (Al's
stat()example for instance). It seems like we ought to shoot for a solution that doesn't rely (solely) on inode and dentry refcounts.
Note that NFSv4 write delegations will need to affect stat as well. (Once you let a client perform writes locally, that client becomes the authority on the attributes, so we have to call back to it on stat.)
--b.
Quoted 8 lines · On Mon, 8 Jul 2013 10:17:01 -0400 Bruce Fields <[email protected]> wrote:
Quoted 6 lines · Jeff Layton
I think the bigger issue though is that looking at refcounts in order to determine when we have a conflicting open is just plain wrong. There are all sorts of reasons one might see a raised refcount that don't involve conflicting opens (Al's
stat()example for instance). It seems like we ought to shoot for a solution that doesn't rely (solely) on inode and dentry refcounts.
Quoted 5 lines
Note that NFSv4 write delegations will need to affect stat as well. (Once you let a client perform writes locally, that client becomes the authority on the attributes, so we have to call back to it on stat.)
--b.
Good point...
I'm a little leery of changing how that check is done anyway. While it seems intuitive to (re)implement the i_readcount in a similar way to the i_writecount, I'd be concerned about callers relying on the existing behavior. So, I'm inclined to try and fix the race that Al has identified without changing the logic too much.
Signature · 1 line
Jeff Layton <[email protected]>
Quoted 11 lines · Bruce Fields
Quoted 6 lines · Jeff Layton
I think the bigger issue though is that looking at refcounts in order to determine when we have a conflicting open is just plain wrong. There are all sorts of reasons one might see a raised refcount that don't involve conflicting opens (Al's
stat()example for instance). It seems like we ought to shoot for a solution that doesn't rely (solely) on inode and dentry refcounts.Note that NFSv4 write delegations will need to affect stat as well. (Once you let a client perform writes locally, that client becomes the authority on the attributes, so we have to call back to it on stat.)
Umm... Yes, but are we ever really going to want to implement that part of the spec? All the client can tell you is 'this file is dirty' and/or it can tell you that a size change has occurred.
It's cute that the protocol allows you to do this, but it's not particularly practical.
Signature · 6 lines
Trond Myklebust Linux NFS client maintainer NetApp [email protected] www.netapp.com
Quoted 13 lines · Trond
Quoted 11 lines · Bruce Fields
Quoted 6 lines · Jeff Layton
I think the bigger issue though is that looking at refcounts in order to determine when we have a conflicting open is just plain wrong. There are all sorts of reasons one might see a raised refcount that don't involve conflicting opens (Al's
stat()example for instance). It seems like we ought to shoot for a solution that doesn't rely (solely) on inode and dentry refcounts.Note that NFSv4 write delegations will need to affect stat as well. (Once you let a client perform writes locally, that client becomes the authority on the attributes, so we have to call back to it on stat.)
Quoted 6 lines
Umm... Yes, but are we ever really going to want to implement that part of the spec? All the client can tell you is 'this file is dirty' and/or it can tell you that a size change has occurred.
It's cute that the protocol allows you to do this, but it's not particularly practical.
If we don't take some sort of action on stat then I don't see how to avoid e.g. breaking "make".
(That action doesn't necessarily have to be a CB_GETATTR to the client and a blind return of the results.)
--b.
Quoted 18 lines · Bruce Fields
Quoted 17 lines · Trond
Quoted 11 lines · Bruce Fields
Quoted 6 lines · Jeff Layton
I think the bigger issue though is that looking at refcounts in order to determine when we have a conflicting open is just plain wrong. There are all sorts of reasons one might see a raised refcount that don't involve conflicting opens (Al's
stat()example for instance). It seems like we ought to shoot for a solution that doesn't rely (solely) on inode and dentry refcounts.Note that NFSv4 write delegations will need to affect stat as well. (Once you let a client perform writes locally, that client becomes the authority on the attributes, so we have to call back to it on stat.)
Umm... Yes, but are we ever really going to want to implement that part of the spec? All the client can tell you is 'this file is dirty' and/or it can tell you that a size change has occurred.
Quoted 5 lines
Quoted 2 lines
It's cute that the protocol allows you to do this, but it's not particularly practical.
If we don't take some sort of action on stat then I don't see how to avoid e.g. breaking "make".
We already cache writes without breaking "make". Why do you think the presence of a delegation must necessarily change everything?
Signature · 6 lines
Trond Myklebust Linux NFS client maintainer NetApp [email protected] www.netapp.com
Quoted 19 lines · Trond
Quoted 18 lines · Bruce Fields
Quoted 17 lines · Trond
Quoted 11 lines · Bruce Fields
Quoted 6 lines · Jeff Layton
I think the bigger issue though is that looking at refcounts in order to determine when we have a conflicting open is just plain wrong. There are all sorts of reasons one might see a raised refcount that don't involve conflicting opens (Al's
stat()example for instance). It seems like we ought to shoot for a solution that doesn't rely (solely) on inode and dentry refcounts.Note that NFSv4 write delegations will need to affect stat as well. (Once you let a client perform writes locally, that client becomes the authority on the attributes, so we have to call back to it on stat.)
Umm... Yes, but are we ever really going to want to implement that part of the spec? All the client can tell you is 'this file is dirty' and/or it can tell you that a size change has occurred.
Quoted 8 lines
Quoted 5 lines
Quoted 2 lines
It's cute that the protocol allows you to do this, but it's not particularly practical.
If we don't take some sort of action on stat then I don't see how to avoid e.g. breaking "make".
We already cache writes without breaking "make". Why do you think the presence of a delegation must necessarily change everything?
As long as it holds a write delegation a client can delay updating data or attributes arbitrarily--so if the server continues to return the old attributes then e.g. "make" could fail to notice an update even long after no application on any client is accessing the file any more.
Could you explain what I'm missing?
--b.
Quoted 29 lines · Bruce Fields
Quoted 19 lines · Trond
Quoted 18 lines · Bruce Fields
Quoted 17 lines · Trond
Quoted 11 lines · Bruce Fields
Quoted 6 lines · Jeff Layton
I think the bigger issue though is that looking at refcounts in order to determine when we have a conflicting open is just plain wrong. There are all sorts of reasons one might see a raised refcount that don't involve conflicting opens (Al's
stat()example for instance). It seems like we ought to shoot for a solution that doesn't rely (solely) on inode and dentry refcounts.Note that NFSv4 write delegations will need to affect stat as well. (Once you let a client perform writes locally, that client becomes the authority on the attributes, so we have to call back to it on stat.)
Umm... Yes, but are we ever really going to want to implement that part of the spec? All the client can tell you is 'this file is dirty' and/or it can tell you that a size change has occurred.
Quoted 8 lines
Quoted 5 lines
Quoted 2 lines
It's cute that the protocol allows you to do this, but it's not particularly practical.
If we don't take some sort of action on stat then I don't see how to avoid e.g. breaking "make".
We already cache writes without breaking "make". Why do you think the presence of a delegation must necessarily change everything?
Quoted 6 lines
As long as it holds a write delegation a client can delay updating data or attributes arbitrarily--so if the server continues to return the old attributes then e.g. "make" could fail to notice an update even long after no application on any client is accessing the file any more.
Could you explain what I'm missing?
An explanation for why the client would want to do this.
Signature · 6 lines
Trond Myklebust Linux NFS client maintainer NetApp [email protected] www.netapp.com
Quoted 30 lines · Trond
Quoted 29 lines · Bruce Fields
Quoted 27 lines · Trond
Quoted 18 lines · Bruce Fields
Quoted 17 lines · Trond
Quoted 11 lines · Bruce Fields
Quoted 6 lines · Jeff Layton
I think the bigger issue though is that looking at refcounts in order to determine when we have a conflicting open is just plain wrong. There are all sorts of reasons one might see a raised refcount that don't involve conflicting opens (Al's
stat()example for instance). It seems like we ought to shoot for a solution that doesn't rely (solely) on inode and dentry refcounts.Note that NFSv4 write delegations will need to affect stat as well. (Once you let a client perform writes locally, that client becomes the authority on the attributes, so we have to call back to it on stat.)
Umm... Yes, but are we ever really going to want to implement that part of the spec? All the client can tell you is 'this file is dirty' and/or it can tell you that a size change has occurred.
Quoted 5 lines
Quoted 2 lines
It's cute that the protocol allows you to do this, but it's not particularly practical.
If we don't take some sort of action on stat then I don't see how to avoid e.g. breaking "make".
We already cache writes without breaking "make". Why do you think the presence of a delegation must necessarily change everything?
Quoted 8 lines
Quoted 6 lines
As long as it holds a write delegation a client can delay updating data or attributes arbitrarily--so if the server continues to return the old attributes then e.g. "make" could fail to notice an update even long after no application on any client is accessing the file any more.
Could you explain what I'm missing?
An explanation for why the client would want to do this.
To reduce the latency of the close operation? The RFCs clearly permit it.
But I know you know that, so I think you're saying that the mechanisms described in the rfc don't work as the authors seemed to intend, and any careful client will be required to do something on close anyway.
Is that correct? Could you explain your thinking?
I believe you--and I'll be delighted to get out of having to hook stat--but I don't see it yet.
It looks to me like the server can implement write delegations by either
1) breaking delegations on every stat or 2) doing a cb_getattr on stat and then recalling only if the return indicates the client has dirty data.
Is your argument that this will require breaking delegations too frequently to make write delegations practical, hence that clients and server will still have to depend on clients doing some minimal update of the file on close?
--b.
Quoted 49 lines · Bruce Fields
Quoted 30 lines · Trond
Quoted 29 lines · Bruce Fields
Quoted 27 lines · Trond
Quoted 18 lines · Bruce Fields
Quoted 17 lines · Trond
Quoted 11 lines · Bruce Fields
Quoted 6 lines · Jeff Layton
I think the bigger issue though is that looking at refcounts in order to determine when we have a conflicting open is just plain wrong. There are all sorts of reasons one might see a raised refcount that don't involve conflicting opens (Al's
stat()example for instance). It seems like we ought to shoot for a solution that doesn't rely (solely) on inode and dentry refcounts.Note that NFSv4 write delegations will need to affect stat as well. (Once you let a client perform writes locally, that client becomes the authority on the attributes, so we have to call back to it on stat.)
Umm... Yes, but are we ever really going to want to implement that part of the spec? All the client can tell you is 'this file is dirty' and/or it can tell you that a size change has occurred.
Quoted 5 lines
Quoted 2 lines
It's cute that the protocol allows you to do this, but it's not particularly practical.
If we don't take some sort of action on stat then I don't see how to avoid e.g. breaking "make".
We already cache writes without breaking "make". Why do you think the presence of a delegation must necessarily change everything?
Quoted 8 lines
Quoted 6 lines
As long as it holds a write delegation a client can delay updating data or attributes arbitrarily--so if the server continues to return the old attributes then e.g. "make" could fail to notice an update even long after no application on any client is accessing the file any more.
Could you explain what I'm missing?
An explanation for why the client would want to do this.
To reduce the latency of the close operation? The RFCs clearly permit it.
But I know you know that, so I think you're saying that the mechanisms described in the rfc don't work as the authors seemed to intend, and any careful client will be required to do something on close anyway.
Is that correct? Could you explain your thinking?
Quoted 7 lines
I believe you--and I'll be delighted to get out of having to hook stat--but I don't see it yet.
It looks to me like the server can implement write delegations by either
1) breaking delegations on every stat or 2) doing acb_getattron stat and then recalling only if the return indicates the client has dirty data.
Why must you recall if you the cb_getattr shows dirty data? Just bumping the change attribute should suffice to keep 'make' and friends happy. They can then trigger the recall by deciding to open the file.
Quoted 4 lines
Is your argument that this will require breaking delegations too frequently to make write delegations practical, hence that clients and server will still have to depend on clients doing some minimal update of the file on close?
Yes. Right now, our client does relax the rules to not send the COMMIT; the write delegation ensures that we can recover safely in case of a server reboot. However we do still actively flush out the WRITEs to reduce the burden of delegation recalls, and also to ensure that we don't have to worry about the whole delegation writeback quota business...
Signature · 6 lines
Trond Myklebust Linux NFS client maintainer NetApp [email protected] www.netapp.com
Quoted 6 lines · Trond
Quoted 4 lines · Bruce Fields
Is your argument that this will require breaking delegations too frequently to make write delegations practical, hence that clients and server will still have to depend on clients doing some minimal update of the file on close?
Quoted 6 lines
Yes. Right now, our client does relax the rules to not send the COMMIT; the write delegation ensures that we can recover safely in case of a server reboot. However we do still actively flush out the WRITEs to reduce the burden of delegation recalls, and also to ensure that we don't have to worry about the whole delegation writeback quota business...
OK, so: we should assume that a client will do what's necessary to update the server attributes on close, such that the server won't need to do something new on stat to prevent a regression in consistency semantics when we implement write delegations.
That makes sense to me.
But (unless I'm totally misreading) the RFC authors clearly expected clients to delay that stuff on close.
Specs aren't manuals for how to write a good implementation, I understand that, but--here you're asking me to assume client implementors will all do something that the spec goes out of its way to tell them they don't have to do.
So I'd be more comfortable if I'd seen some ietf discussion of that. I'll go start it if need be. (Or maybe there already was some and I missed it.)
--b.