shouldn't that be:
changed_extents = p != fnode.extents.end();
?

No, because cutting tail for an extent is also a change.

Not sure I'm getting this point.
When p ==fnode.extents.end() (and hence cut_off == 0) there is nothing to cut at the tail IMO. And hence there is no need to update the log etc... I can only imagine one case - when truncate effectively expands the fnode up to allocated boundary. And one needs to update fnode.size then. Do you mean this case?

I might be missing something.

AAAABBBBCCCCDDDDEEEE
    ^case 1, remove B-E
AAAABBBBCCCCDDDDEEEE
     ^case 2, cut B, remove C-E
AAAABBBBCCCCDDDDEEEE
       ^case 3, whole B remains, remove C-E         

So in case 1, cut_off == 0 but p!=fnode.extents.end().

The problem is different, and I think I get the confusion.
In case of p == fnode.extents.end() the whole extent dropping part should be skipped altogether and no log updated.
@ifed01 ?

Right, that's what I meant

This should never happen given fnode.seek() implementation and
implicit p != fnode.extents.end() check above.

May be replace with assert(false)?

Right. This is else to cut_off < p->length. At this point I would be checking a compiler.
Removed.

This branch cannot be eliminated.
There are 3 distinct cases:

1. extent we seek to is not used at all
2. we use some, but there is something to cut and release
3. we use some and there is nothing to cut and release
   I feel like separate codes for each case is the best solution.

So case 3 is when cut_off is equal to p->length not "greater or equal"? I can't imagine why cut_off could be greater than p->length.
If so than the comment is confusing there.

In normal case, we expect only cut_off == p->length.
In corruption case:
cut_off could be greater then p->length when the extent was not aligned to required allocation unit.
But in this case it should be assert.
So, how about ceph_assert(cut_off == p->length) ?

yeah, sounds good to me