tree 2a82476c0f531babace3ada208e6bd4a4f83c6cc
parent e4f82bf21f2586aa823fd40de72023236062a4aa
author Bob Peterson <rpeterso@redhat.com> 1683222202 -0400
committer Andreas Gruenbacher <agruenba@redhat.com> 1686069306 +0200

gfs2: ignore rindex_update failure in dinode_dealloc

Before this patch, function gfs2_dinode_dealloc would abort if it got a
bad return code from gfs2_rindex_update(). The problem is that it left the
dinode in the unlinked (not free) state, which meant subsequent fsck
would clean it up and flag an error. That meant some of our QE tests
would fail.

The sole purpose of gfs2_rindex_update(), in this code path, is to read in
any newer rgrps added by gfs2_grow. But since this is a delete operation
it won't actually use any of those new rgrps. It can really only twiddle
the bits from "Unlinked" to "Free" in an existing rgrp. Therefore the
error should not prevent the transition from unlinked to free.

This patch makes gfs2_dinode_dealloc ignore the bad return code and
proceed with freeing the dinode so the QE tests will not be tripped up.

Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
