Merge pull request ceph#61945 from kotreshhr/snapshot-referent-inodes

mds: snapshot referent inodes feature

Reviewed-by: Venky Shankar <[email protected]>

Author: vshankar

qa/suites/fs/functional/tasks/referent.yaml

@@ -0,0 +1,4 @@
+tasks:
+  - cephfs_test_runner:
+      modules:
+        - tasks.cephfs.test_referent

qa/tasks/cephfs/cephfs_test_case.py

@@ -71,6 +71,7 @@ class CephFSTestCase(CephTestCase):
     CLIENTS_REQUIRED = 1
     MDSS_REQUIRED = 1
     REQUIRE_ONE_CLIENT_REMOTE = False
+    ALLOW_REFERENT_INODES = False
 
     # Whether to create the default filesystem during setUp
     REQUIRE_FILESYSTEM = True
@@ -190,6 +191,10 @@ def setUp(self):
             for i in range(0, self.CLIENTS_REQUIRED):
                 self.mounts[i].mount_wait()
 
+            # enable referent inodes
+            if self.ALLOW_REFERENT_INODES:
+              self.fs.set_allow_referent_inodes(True)
+
         if self.REQUIRE_BACKUP_FILESYSTEM:
             if not self.REQUIRE_FILESYSTEM:
                 self.skipTest("backup filesystem requires a primary filesystem as well")

qa/tasks/cephfs/filesystem.py

@@ -665,6 +665,9 @@ def set_allow_standby_replay(self, yes):
     def set_allow_new_snaps(self, yes):
         self.set_var("allow_new_snaps", yes, '--yes-i-really-mean-it')
 
+    def set_allow_referent_inodes(self, yes):
+        self.set_var("allow_referent_inodes", yes)
+
     def set_bal_rank_mask(self, bal_rank_mask):
         self.set_var("bal_rank_mask", bal_rank_mask)
 
@@ -1319,9 +1322,15 @@ def wait_for_daemons(self, timeout=None, skip_max_mds_check=False, status=None):
 
             status = self.status()
 
-    def dencoder(self, obj_type, obj_blob):
-        args = [os.path.join(self._prefix, "ceph-dencoder"), 'type', obj_type, 'import', '-', 'decode', 'dump_json']
+    def dencoder(self, obj_type, obj_blob, skip=0, stray_okay=False):
+        args = [os.path.join(self._prefix, "ceph-dencoder"), 'type', obj_type]
+        if stray_okay:
+            args.extend(["stray_okay"])
+        if skip != 0 :
+            args.extend(["skip", str(skip)])
+        args.extend(['import', '-', 'decode', 'dump_json'])
         p = self.mon_manager.controller.run(args=args, stdin=BytesIO(obj_blob), stdout=BytesIO())
+
         return p.stdout.getvalue()
 
     def rados(self, *args, **kwargs):
@@ -1538,6 +1547,43 @@ def _write_data_xattr(self, ino_no, xattr_name, data, pool=None):
         args = ["setxattr", obj_name, xattr_name, data]
         self.rados(args, pool=pool)
 
+    def read_meta_inode(self, dir_ino, file_name, pool=None):
+        """
+        Get decoded in-memory inode from the metadata pool
+        """
+        if pool is None:
+            pool = self.get_metadata_pool_name()
+
+        dirfrag_obj_name = "{0:x}.00000000".format(dir_ino)
+        args=["getomapval", dirfrag_obj_name, file_name+"_head", "-"]
+        try:
+            proc = self.rados(args, pool=pool, stdout=BytesIO())
+        except CommandFailedError as e:
+            log.error(e.__str__())
+            raise ObjectNotFound(dirfrag_obj_name)
+
+        obj_blob = proc.stdout.getvalue()
+        return json.loads(self.dencoder("inode_t<std::allocator>", obj_blob, 25, True).strip())
+
+    def read_remote_inode(self, ino_no, pool=None):
+        """
+        Read the remote_inode xattr from the data pool, return a dict in the
+        format given by inodeno_t::dump, which is something like:
+
+        ::
+
+            rados -p cephfs_data getxattr 100000001f8.00000000 remote_inode > out.bin
+            ceph-dencoder type inodeno_t import out.bin decode dump_json
+
+            {
+                 "val": 1099511627778
+            }
+
+        :param pool: name of pool to read backtrace from.  If omitted, FS must have only
+                     one data pool and that will be used.
+        """
+        return self._read_data_xattr(ino_no, "remote_inode", "inodeno_t", pool)
+
     def read_symlink(self, ino_no, pool=None):
         return self._read_data_xattr(ino_no, "symlink", "string_wrapper", pool)
 
@@ -1601,6 +1647,15 @@ def _enumerate_data_objects(self, ino, size):
 
         return want_objects, exist_objects
 
+    def list_data_objects (self):
+        """
+        Get the list of existing data objects in the data pool
+        """
+        existing_objects = self.rados(["ls"], pool=self.get_data_pool_name(), stdout=StringIO()).stdout.getvalue().split("\n")
+
+        return existing_objects
+
+
     def data_objects_present(self, ino, size):
         """
         Check that *all* the expected data objects for an inode are present in the data pool

qa/tasks/cephfs/test_backtrace.py

@@ -5,8 +5,8 @@
 class TestBacktrace(CephFSTestCase):
     def test_backtrace(self):
         """
-        That the 'parent' 'layout' and 'symlink' xattrs on the head objects of files
-        are updated correctly.
+        That the 'parent', 'layout', 'symlink' and 'remote_inode' xattrs on the
+        head objects of files are updated correctly.
         """
 
         old_data_pool_name = self.fs.get_data_pool_name()
@@ -36,6 +36,33 @@ def test_backtrace(self):
             "s" : "./file1",
             })
 
+        # Disabling referent_inodes fs option should not create referent inode  and
+        # and therefore no 'remote_inode' xattr on hardlink creation
+        self.fs.set_allow_referent_inodes(False);
+        self.mount_a.run_shell(["mkdir", "hardlink_dir0"])
+        self.mount_a.run_shell(["touch", "hardlink_dir0/file1"])
+        self.mount_a.run_shell(["ln", "hardlink_dir0/file1", "hardlink_dir0/hl_file1"])
+        self.fs.mds_asok(["flush", "journal"])
+
+        file1_ino = self.mount_a.path_to_ino("hardlink_dir0/file1", follow_symlinks=False)
+        file1_inode_dump = self.fs.mds_asok(['dump', 'inode', hex(file1_ino)])
+        self.assertListEqual(file1_inode_dump['referent_inodes'], [])
+
+        # Enabling referent_inodes fs option should store 'remote_inode' xattr
+        # on hardlink creation
+        self.fs.set_allow_referent_inodes(True);
+        self.mount_a.run_shell(["mkdir", "hardlink_dir"])
+        self.mount_a.run_shell(["touch", "hardlink_dir/file1"])
+        self.mount_a.run_shell(["ln", "hardlink_dir/file1", "hardlink_dir/hl_file1"])
+        self.fs.mds_asok(["flush", "journal"])
+
+        file1_ino = self.mount_a.path_to_ino("hardlink_dir/file1", follow_symlinks=False)
+        file1_inode_dump = self.fs.mds_asok(['dump', 'inode', hex(file1_ino)])
+        referent_ino = file1_inode_dump["referent_inodes"][0]
+
+        remote_inode_xattr = self.fs.read_remote_inode(referent_ino)
+        self.assertEqual(remote_inode_xattr['val'], file1_ino)
+
         # Create a file for subsequent checks
         self.mount_a.run_shell(["mkdir", "parent_a"])
         self.mount_a.run_shell(["touch", "parent_a/alpha"])

qa/tasks/cephfs/test_data_scan.py

@@ -164,6 +164,44 @@ def validate(self):
         self.assert_equal(target, "symdir/onemegs")
         return self._errors
 
+class HardlinkWorkload(Workload):
+    """
+    Hardlink file, check that it gets recovered as hardlink
+    with referent inode pointing to the remote inode
+    """
+    def write(self):
+        self._filesystem.set_allow_referent_inodes(True);
+        self._mount.run_shell(["mkdir", "hardlink_dir"])
+        self._mount.write_n_mb("hardlink_dir/file1", 1)
+        self._mount.run_shell(["ln", "hardlink_dir/file1", "hardlink_dir/hl_file1"])
+        self._mount.run_shell(["ln", "hardlink_dir/file1", "hardlink_dir/hl_file2"])
+        self._filesystem.set_allow_referent_inodes(False);
+
+    def validate(self):
+        self._mount.run_shell(["sudo", "ls", "hardlink_dir"], omit_sudo=False)
+        st_file1 = self._mount.lstat("hardlink_dir/file1")
+        st_hl_file1 = self._mount.lstat("hardlink_dir/hl_file1")
+        st_hl_file2 = self._mount.lstat("hardlink_dir/hl_file2")
+        # link count check
+        self.assert_equal(3, st_file1['st_nlink'])
+        self.assert_equal(3, st_hl_file1['st_nlink'])
+        self.assert_equal(3, st_hl_file2['st_nlink'])
+        # ino number check
+        self.assert_equal(st_file1['st_ino'], st_hl_file1['st_ino'])
+        self.assert_equal(st_file1['st_ino'], st_hl_file2['st_ino'])
+        # reverse link - referent inode list
+        file1_ino = self._mount.path_to_ino("hardlink_dir/file1", follow_symlinks=False)
+        file1_inode_dump = self._filesystem.mds_asok(['dump', 'inode', hex(file1_ino)])
+        self.assert_equal(len(file1_inode_dump['referent_inodes']), 2)
+        # remote link
+        referent1_ino = file1_inode_dump['referent_inodes'][0]
+        referent1_inode_dump = self._filesystem.mds_asok(['dump', 'inode', hex(referent1_ino)])
+        self.assert_equal(file1_ino, referent1_inode_dump['remote_ino'])
+        referent2_ino = file1_inode_dump['referent_inodes'][1]
+        referent2_inode_dump = self._filesystem.mds_asok(['dump', 'inode', hex(referent2_ino)])
+        self.assert_equal(file1_ino, referent2_inode_dump['remote_ino'])
+        return self._errors
+
 class NestedDirWorkload(Workload):
     """
     Nested directories, one is lost.
@@ -540,6 +578,9 @@ def test_rebuild_simple(self):
     def test_rebuild_symlink(self):
         self._rebuild_metadata(SymlinkWorkload(self.fs, self.mount_a))
 
+    def test_rebuild_hardlink(self):
+        self._rebuild_metadata(HardlinkWorkload(self.fs, self.mount_a))
+
     def test_rebuild_nested(self):
         self._rebuild_metadata(NestedDirWorkload(self.fs, self.mount_a))