afs: Fix missing subdir edit when renamed between parent dirs

When rename moves an AFS subdirectory between parent directories, the
subdir also needs a bit of editing: the ".." entry needs updating to point
to the new parent (though I don't make use of the info) and the DV needs
incrementing by 1 to reflect the change of content.  The server also sends
a callback break notification on the subdirectory if we have one, but we
can take care of recovering the promise next time we access the subdir.

This can be triggered by something like:

    mount -t afs %example.com:xfstest.test20 /xfstest.test/
    mkdir /xfstest.test/{aaa,bbb,aaa/ccc}
    touch /xfstest.test/bbb/ccc/d
    mv /xfstest.test/{aaa/ccc,bbb/ccc}
    touch /xfstest.test/bbb/ccc/e

When the pathwalk for the second touch hits "ccc", kafs spots that the DV
is incorrect and downloads it again (so the fix is not critical).

Fix this, if the rename target is a directory and the old and new
parents are different, by:

 (1) Incrementing the DV number of the target locally.

 (2) Editing the ".." entry in the target to refer to its new parent's
     vnode ID and uniquifier.

Link: https://lore.kernel.org/r/3340431.1729680010@warthog.procyon.org.uk
Fixes: 63a4681ff39c ("afs: Locally edit directory data for mkdir/create/unlink/...")
cc: David Howells <dhowells@redhat.com>
cc: Marc Dionne <marc.dionne@auristor.com>
cc: linux-afs@lists.infradead.org
Signed-off-by: David Howells <dhowells@redhat.com>
Signed-off-by: Christian Brauner <brauner@kernel.org>

diff --git a/fs/afs/dir.c b/fs/afs/dir.c
index f8622ed72e08126aebfb9ede3943ba54469b2d78..ada363af5aab8e8e1fc806327dfecae1d4ca14cb 100644 (file)
--- a/fs/afs/dir.c
+++ b/fs/afs/dir.c
@@ -12,6 +12,7 @@
 #include <linux/swap.h>
 #include <linux/ctype.h>
 #include <linux/sched.h>
+#include <linux/iversion.h>
 #include <linux/task_io_accounting_ops.h>
 #include "internal.h"
 #include "afs_fs.h"
@@ -1823,6 +1824,8 @@ error:
 
 static void afs_rename_success(struct afs_operation *op)
 {
+       struct afs_vnode *vnode = AFS_FS_I(d_inode(op->dentry));
+
        _enter("op=%08x", op->debug_id);
 
        op->ctime = op->file[0].scb.status.mtime_client;
@@ -1832,6 +1835,22 @@ static void afs_rename_success(struct afs_operation *op)
                op->ctime = op->file[1].scb.status.mtime_client;
                afs_vnode_commit_status(op, &op->file[1]);
        }
+
+       /* If we're moving a subdir between dirs, we need to update
+        * its DV counter too as the ".." will be altered.
+        */
+       if (S_ISDIR(vnode->netfs.inode.i_mode) &&
+           op->file[0].vnode != op->file[1].vnode) {
+               u64 new_dv;
+
+               write_seqlock(&vnode->cb_lock);
+
+               new_dv = vnode->status.data_version + 1;
+               vnode->status.data_version = new_dv;
+               inode_set_iversion_raw(&vnode->netfs.inode, new_dv);
+
+               write_sequnlock(&vnode->cb_lock);
+       }
 }
 
 static void afs_rename_edit_dir(struct afs_operation *op)
@@ -1873,6 +1892,12 @@ static void afs_rename_edit_dir(struct afs_operation *op)
                                 &vnode->fid, afs_edit_dir_for_rename_2);
        }
 
+       if (S_ISDIR(vnode->netfs.inode.i_mode) &&
+           new_dvnode != orig_dvnode &&
+           test_bit(AFS_VNODE_DIR_VALID, &vnode->flags))
+               afs_edit_dir_update_dotdot(vnode, new_dvnode,
+                                          afs_edit_dir_for_rename_sub);
+
        new_inode = d_inode(new_dentry);
        if (new_inode) {
                spin_lock(&new_inode->i_lock);

diff --git a/fs/afs/dir_edit.c b/fs/afs/dir_edit.c
index a71bff10496b2b9c5282086aec950fe85d79491a..fe223fb781111a4ee5fab5c95c5d0ffc61600123 100644 (file)
--- a/fs/afs/dir_edit.c
+++ b/fs/afs/dir_edit.c
@@ -127,10 +127,10 @@ static struct folio *afs_dir_get_folio(struct afs_vnode *vnode, pgoff_t index)
 /*
  * Scan a directory block looking for a dirent of the right name.
  */
-static int afs_dir_scan_block(union afs_xdr_dir_block *block, struct qstr *name,
+static int afs_dir_scan_block(const union afs_xdr_dir_block *block, const struct qstr *name,
                              unsigned int blocknum)
 {
-       union afs_xdr_dirent *de;
+       const union afs_xdr_dirent *de;
        u64 bitmap;
        int d, len, n;
 
@@ -492,3 +492,90 @@ error:
        clear_bit(AFS_VNODE_DIR_VALID, &vnode->flags);
        goto out_unmap;
 }
+
+/*
+ * Edit a subdirectory that has been moved between directories to update the
+ * ".." entry.
+ */
+void afs_edit_dir_update_dotdot(struct afs_vnode *vnode, struct afs_vnode *new_dvnode,
+                               enum afs_edit_dir_reason why)
+{
+       union afs_xdr_dir_block *block;
+       union afs_xdr_dirent *de;
+       struct folio *folio;
+       unsigned int nr_blocks, b;
+       pgoff_t index;
+       loff_t i_size;
+       int slot;
+
+       _enter("");
+
+       i_size = i_size_read(&vnode->netfs.inode);
+       if (i_size < AFS_DIR_BLOCK_SIZE) {
+               clear_bit(AFS_VNODE_DIR_VALID, &vnode->flags);
+               return;
+       }
+       nr_blocks = i_size / AFS_DIR_BLOCK_SIZE;
+
+       /* Find a block that has sufficient slots available.  Each folio
+        * contains two or more directory blocks.
+        */
+       for (b = 0; b < nr_blocks; b++) {
+               index = b / AFS_DIR_BLOCKS_PER_PAGE;
+               folio = afs_dir_get_folio(vnode, index);
+               if (!folio)
+                       goto error;
+
+               block = kmap_local_folio(folio, b * AFS_DIR_BLOCK_SIZE - folio_pos(folio));
+
+               /* Abandon the edit if we got a callback break. */
+               if (!test_bit(AFS_VNODE_DIR_VALID, &vnode->flags))
+                       goto invalidated;
+
+               slot = afs_dir_scan_block(block, &dotdot_name, b);
+               if (slot >= 0)
+                       goto found_dirent;
+
+               kunmap_local(block);
+               folio_unlock(folio);
+               folio_put(folio);
+       }
+
+       /* Didn't find the dirent to clobber.  Download the directory again. */
+       trace_afs_edit_dir(vnode, why, afs_edit_dir_update_nodd,
+                          0, 0, 0, 0, "..");
+       clear_bit(AFS_VNODE_DIR_VALID, &vnode->flags);
+       goto out;
+
+found_dirent:
+       de = &block->dirents[slot];
+       de->u.vnode  = htonl(new_dvnode->fid.vnode);
+       de->u.unique = htonl(new_dvnode->fid.unique);
+
+       trace_afs_edit_dir(vnode, why, afs_edit_dir_update_dd, b, slot,
+                          ntohl(de->u.vnode), ntohl(de->u.unique), "..");
+
+       kunmap_local(block);
+       folio_unlock(folio);
+       folio_put(folio);
+       inode_set_iversion_raw(&vnode->netfs.inode, vnode->status.data_version);
+
+out:
+       _leave("");
+       return;
+
+invalidated:
+       kunmap_local(block);
+       folio_unlock(folio);
+       folio_put(folio);
+       trace_afs_edit_dir(vnode, why, afs_edit_dir_update_inval,
+                          0, 0, 0, 0, "..");
+       clear_bit(AFS_VNODE_DIR_VALID, &vnode->flags);
+       goto out;
+
+error:
+       trace_afs_edit_dir(vnode, why, afs_edit_dir_update_error,
+                          0, 0, 0, 0, "..");
+       clear_bit(AFS_VNODE_DIR_VALID, &vnode->flags);
+       goto out;
+}

diff --git a/fs/afs/internal.h b/fs/afs/internal.h
index 6e1d3c4daf72c6578b173b32364a1e136c7b6fec..b306c09808706b306cd3cf3d01d79be5da8b8d36 100644 (file)
--- a/fs/afs/internal.h
+++ b/fs/afs/internal.h
@@ -1072,6 +1072,8 @@ extern void afs_check_for_remote_deletion(struct afs_operation *);
 extern void afs_edit_dir_add(struct afs_vnode *, struct qstr *, struct afs_fid *,
                             enum afs_edit_dir_reason);
 extern void afs_edit_dir_remove(struct afs_vnode *, struct qstr *, enum afs_edit_dir_reason);
+void afs_edit_dir_update_dotdot(struct afs_vnode *vnode, struct afs_vnode *new_dvnode,
+                               enum afs_edit_dir_reason why);
 
 /*
  * dir_silly.c

diff --git a/include/trace/events/afs.h b/include/trace/events/afs.h
index 450c44c83a5d21bad22485efbb5734c47edb0125..a0aed1a428a18370140dcd29bebdcfc06ff2a994 100644 (file)
--- a/include/trace/events/afs.h
+++ b/include/trace/events/afs.h
@@ -331,7 +331,11 @@ enum yfs_cm_operation {
        EM(afs_edit_dir_delete,                 "delete") \
        EM(afs_edit_dir_delete_error,           "d_err ") \
        EM(afs_edit_dir_delete_inval,           "d_invl") \
-       E_(afs_edit_dir_delete_noent,           "d_nent")
+       EM(afs_edit_dir_delete_noent,           "d_nent") \
+       EM(afs_edit_dir_update_dd,              "u_ddot") \
+       EM(afs_edit_dir_update_error,           "u_fail") \
+       EM(afs_edit_dir_update_inval,           "u_invl") \
+       E_(afs_edit_dir_update_nodd,            "u_nodd")
 
 #define afs_edit_dir_reasons                             \
        EM(afs_edit_dir_for_create,             "Create") \
@@ -340,6 +344,7 @@ enum yfs_cm_operation {
        EM(afs_edit_dir_for_rename_0,           "Renam0") \
        EM(afs_edit_dir_for_rename_1,           "Renam1") \
        EM(afs_edit_dir_for_rename_2,           "Renam2") \
+       EM(afs_edit_dir_for_rename_sub,         "RnmSub") \
        EM(afs_edit_dir_for_rmdir,              "RmDir ") \
        EM(afs_edit_dir_for_silly_0,            "S_Ren0") \
        EM(afs_edit_dir_for_silly_1,            "S_Ren1") \