diff --git a/init/README.md b/init/README.md
index 64c6b1c..6c29b07 100644
--- a/init/README.md
+++ b/init/README.md
@@ -733,7 +733,10 @@
 `verity_update_state`
 > Internal implementation detail used to update dm-verity state and
   set the partition._mount-point_.verified properties used by adb remount
-  because fs\_mgr can't set them directly itself.
+  because fs\_mgr can't set them directly itself. This is required since
+  Android 12, because CtsNativeVerifiedBootTestCases will read property
+  "partition.${partition}.verified.hash_alg" to check that sha1 is not used.
+  See https://r.android.com/1546980 for more details.
 
 `wait <path> [ <timeout> ]`
 > Poll for the existence of the given file and return when found,
diff --git a/rootdir/init.rc b/rootdir/init.rc
index 530761a..27fa059 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -1101,6 +1101,9 @@
     # Define default initial receive window size in segments.
     setprop net.tcp_def_init_rwnd 60
 
+    # Update dm-verity state and set partition.*.verified properties.
+    verity_update_state
+
     # Start standard binderized HAL daemons
     class_start hal
 
