Change API to check owners, instead of returning account meta

Author: pgarg66

runtime/src/accounts_db.rs

@@ -42,9 +42,9 @@ use {
             get_ancient_append_vec_capacity, is_ancient, AccountsToStore, StorageSelector,
         },
         append_vec::{
-            aligned_stored_size, AccountMeta, AppendVec,
-            StorableAccountsWithHashesAndWriteVersions, StoredAccountMeta, StoredMetaWriteVersion,
-            APPEND_VEC_MMAPPED_FILES_OPEN, STORE_META_OVERHEAD,
+            aligned_stored_size, AppendVec, StorableAccountsWithHashesAndWriteVersions,
+            StoredAccountMeta, StoredMetaWriteVersion, APPEND_VEC_MMAPPED_FILES_OPEN,
+            STORE_META_OVERHEAD,
         },
         cache_hash_data::{CacheHashData, CacheHashDataFile},
         contains::Contains,
@@ -810,24 +810,21 @@ impl<'a> LoadedAccountAccessor<'a> {
         }
     }
 
-    fn get_account_meta(&self) -> Option<AccountMeta> {
+    fn account_matches_owners(&self, owners: &[&Pubkey]) -> Option<bool> {
         match self {
-            LoadedAccountAccessor::Cached(cached_account) => {
-                cached_account.as_ref().map(|cached_account| AccountMeta {
-                    lamports: cached_account.account.lamports(),
-                    rent_epoch: cached_account.account.rent_epoch(),
-                    owner: *cached_account.account.owner(),
-                    executable: cached_account.account.executable(),
-                })
-            }
+            LoadedAccountAccessor::Cached(cached_account) => cached_account
+                .as_ref()
+                .map(|cached_account| owners.contains(&cached_account.account.owner())),
             LoadedAccountAccessor::Stored(maybe_storage_entry) => {
                 // storage entry may not be present if slot was cleaned up in
                 // between reading the accounts index and calling this function to
                 // get account meta from the storage entry here
                 maybe_storage_entry
                     .as_ref()
                     .and_then(|(storage_entry, offset)| {
-                        storage_entry.accounts.get_account_meta(*offset)
+                        storage_entry
+                            .accounts
+                            .account_matches_owners(*offset, owners)
                     })
             }
         }
@@ -4936,31 +4933,31 @@ impl AccountsDb {
         self.do_load(ancestors, pubkey, None, load_hint, LoadZeroLamports::None)
     }
 
-    pub fn get_account_meta(&self, ancestors: &Ancestors, pubkey: &Pubkey) -> Option<AccountMeta> {
+    pub fn account_matches_owners(
+        &self,
+        ancestors: &Ancestors,
+        account: &Pubkey,
+        owners: &[&Pubkey],
+    ) -> Option<bool> {
         let (slot, storage_location, _maybe_account_accesor) =
-            self.read_index_for_accessor_or_load_slow(ancestors, pubkey, None, false)?;
+            self.read_index_for_accessor_or_load_slow(ancestors, account, None, false)?;
 
         if !storage_location.is_cached() {
-            let result = self.read_only_accounts_cache.load(*pubkey, slot);
+            let result = self.read_only_accounts_cache.load(*account, slot);
             if let Some(account) = result {
-                return Some(AccountMeta {
-                    lamports: account.lamports(),
-                    rent_epoch: account.rent_epoch(),
-                    owner: *account.owner(),
-                    executable: account.executable(),
-                });
+                return Some(owners.contains(&account.owner()));
             }
         }
 
         let (account_accessor, _slot) = self.retry_to_get_account_accessor(
             slot,
             storage_location,
             ancestors,
-            pubkey,
+            account,
             None,
             LoadHint::Unspecified,
         )?;
-        account_accessor.get_account_meta()
+        account_accessor.account_matches_owners(owners)
     }
 
     pub fn load_account_into_read_cache(&self, ancestors: &Ancestors, pubkey: &Pubkey) {
@@ -14133,43 +14130,54 @@ pub mod tests {
     }
 
     #[test]
-    fn test_get_account_meta() {
+    fn test_account_matches_owners() {
         let db = Arc::new(AccountsDb::new_with_config_for_tests(
             Vec::new(),
             &ClusterType::Development,
             AccountSecondaryIndexes::default(),
             AccountShrinkThreshold::default(),
         ));
 
+        let owners: Vec<Pubkey> = (0..2).map(|_| Pubkey::new_unique()).collect();
+        let owners_refs: Vec<&Pubkey> = owners.iter().collect();
+
         let account1_key = Pubkey::new_unique();
-        let owner1_key = Pubkey::new_unique();
-        let account1 = AccountSharedData::new(321, 10, &owner1_key);
+        let account1 = AccountSharedData::new(321, 10, &owners[0]);
 
         let account2_key = Pubkey::new_unique();
-        let owner2_key = Pubkey::new_unique();
-        let account2 = AccountSharedData::new(1, 1, &owner2_key);
+        let account2 = AccountSharedData::new(1, 1, &owners[1]);
+
+        let account3_key = Pubkey::new_unique();
+        let account3 = AccountSharedData::new(1, 1, &Pubkey::new_unique());
 
         db.store_cached((0, &[(&account1_key, &account1)][..]), None);
         db.store_cached((1, &[(&account2_key, &account2)][..]), None);
+        db.store_cached((2, &[(&account3_key, &account3)][..]), None);
 
         db.add_root(0);
         db.add_root(1);
+        db.add_root(2);
 
         // Flush the cache so that the account meta will be read from the storage
         db.flush_accounts_cache(true, None);
         db.clean_accounts_for_tests();
 
-        let account_meta = db
-            .get_account_meta(&Ancestors::default(), &account1_key)
-            .unwrap();
-        assert_eq!(account_meta.lamports, 321);
-        assert_eq!(account_meta.owner, owner1_key);
-
-        let account_meta = db
-            .get_account_meta(&Ancestors::default(), &account2_key)
-            .unwrap();
-        assert_eq!(account_meta.lamports, 1);
-        assert_eq!(account_meta.owner, owner2_key);
+        assert_eq!(
+            db.account_matches_owners(&Ancestors::default(), &account1_key, &owners_refs),
+            Some(true)
+        );
+        assert_eq!(
+            db.account_matches_owners(&Ancestors::default(), &account2_key, &owners_refs),
+            Some(true)
+        );
+        assert_eq!(
+            db.account_matches_owners(&Ancestors::default(), &account3_key, &owners_refs),
+            Some(false)
+        );
+        assert_eq!(
+            db.account_matches_owners(&Ancestors::default(), &Pubkey::new_unique(), &owners_refs),
+            None
+        );
 
         // Flush the cache and load account1 (so that it's in the cache)
         db.flush_accounts_cache(true, None);
@@ -14184,17 +14192,22 @@ pub mod tests {
             )
             .unwrap();
 
-        let account_meta = db
-            .get_account_meta(&Ancestors::default(), &account1_key)
-            .unwrap();
-        assert_eq!(account_meta.lamports, 321);
-        assert_eq!(account_meta.owner, owner1_key);
-
-        let account_meta = db
-            .get_account_meta(&Ancestors::default(), &account2_key)
-            .unwrap();
-        assert_eq!(account_meta.lamports, 1);
-        assert_eq!(account_meta.owner, owner2_key);
+        assert_eq!(
+            db.account_matches_owners(&Ancestors::default(), &account1_key, &owners_refs),
+            Some(true)
+        );
+        assert_eq!(
+            db.account_matches_owners(&Ancestors::default(), &account2_key, &owners_refs),
+            Some(true)
+        );
+        assert_eq!(
+            db.account_matches_owners(&Ancestors::default(), &account3_key, &owners_refs),
+            Some(false)
+        );
+        assert_eq!(
+            db.account_matches_owners(&Ancestors::default(), &Pubkey::new_unique(), &owners_refs),
+            None
+        );
     }
 
     /// a test that will accept either answer

runtime/src/append_vec.rs

@@ -594,15 +594,17 @@ impl AppendVec {
         ))
     }
 
-    /// Return account metadata for the account at `offset` if its data doesn't overrun
-    /// the internal buffer. Otherwise return None.
-    pub fn get_account_meta(&self, offset: usize) -> Option<AccountMeta> {
+    /// Return Some(true) if the account owner at `offset` is one of the pubkeys in `owners`.
+    /// Return Some(false) if the account owner is not one of the pubkeys in `owners`.
+    /// It returns None if the `offset` value causes a data overrun.
+    pub fn account_matches_owners(&self, offset: usize, owners: &[&Pubkey]) -> Option<bool> {
         // Skip over StoredMeta data in the account
         let offset = offset.checked_add(mem::size_of::<StoredMeta>())?;
         // u64_align! does an unchecked add for alignment. Check that it won't cause an overflow.
         offset.checked_add(ALIGN_BOUNDARY_OFFSET - 1)?;
         let (account_meta, _): (&AccountMeta, _) = self.get_type(u64_align!(offset))?;
-        Some(account_meta.clone())
+
+        Some(owners.contains(&&account_meta.owner))
     }
 
     #[cfg(test)]
@@ -1059,50 +1061,38 @@ pub mod tests {
     }
 
     #[test]
-    fn test_get_account_meta() {
+    fn test_account_matches_owners() {
         let path = get_append_vec_path("test_append_data");
         let av = AppendVec::new(&path.path, true, 1024 * 1024);
-        let mut account = create_test_account(5);
-
-        let test_account_meta = AccountMeta {
-            lamports: 12345678,
-            rent_epoch: 123,
-            owner: Pubkey::new_unique(),
-            executable: true,
-        };
-        account.1.set_lamports(test_account_meta.lamports);
-        account.1.set_rent_epoch(test_account_meta.rent_epoch);
-        account.1.set_owner(test_account_meta.owner);
-        account.1.set_executable(test_account_meta.executable);
+        let owners: Vec<Pubkey> = (0..2).map(|_| Pubkey::new_unique()).collect();
+        let owners_refs: Vec<&Pubkey> = owners.iter().collect();
 
+        let mut account = create_test_account(5);
+        account.1.set_owner(owners[0]);
         let index = av.append_account_test(&account).unwrap();
-        assert_eq!(av.get_account_meta(index), Some(test_account_meta.clone()));
+        assert_eq!(av.account_matches_owners(index, &owners_refs), Some(true));
 
         let mut account1 = create_test_account(6);
-        let test_account_meta1 = AccountMeta {
-            lamports: 87654321,
-            rent_epoch: 234,
-            owner: Pubkey::new_unique(),
-            executable: false,
-        };
-        account1.1.set_lamports(test_account_meta1.lamports);
-        account1.1.set_rent_epoch(test_account_meta1.rent_epoch);
-        account1.1.set_owner(test_account_meta1.owner);
-        account1.1.set_executable(test_account_meta1.executable);
-
+        account1.1.set_owner(owners[1]);
         let index1 = av.append_account_test(&account1).unwrap();
-        assert_eq!(av.get_account_meta(index1), Some(test_account_meta1));
-        assert_eq!(av.get_account_meta(index), Some(test_account_meta));
+        assert_eq!(av.account_matches_owners(index1, &owners_refs), Some(true));
+        assert_eq!(av.account_matches_owners(index, &owners_refs), Some(true));
+
+        let mut account2 = create_test_account(6);
+        account2.1.set_owner(Pubkey::new_unique());
+        let index2 = av.append_account_test(&account2).unwrap();
+        assert_eq!(av.account_matches_owners(index2, &owners_refs), Some(false));
 
         // tests for overflow
         assert_eq!(
-            av.get_account_meta(usize::MAX - mem::size_of::<StoredMeta>()),
+            av.account_matches_owners(usize::MAX - mem::size_of::<StoredMeta>(), &owners_refs),
             None
         );
 
         assert_eq!(
-            av.get_account_meta(
-                usize::MAX - mem::size_of::<StoredMeta>() - mem::size_of::<AccountMeta>() + 1
+            av.account_matches_owners(
+                usize::MAX - mem::size_of::<StoredMeta>() - mem::size_of::<AccountMeta>() + 1,
+                &owners_refs
             ),
             None
         );