Merge branch 'master' into processor-tests

Cargo.toml

@@ -236,7 +236,6 @@ jsonrpc-derive = "18.0.0"
 jsonrpc-http-server = "18.0.0"
 jsonrpc-ipc-server = "18.0.0"
 jsonrpc-pubsub = "18.0.0"
-jsonrpc-server-utils = "18.0.0"
 lazy_static = "1.4.0"
 libc = "0.2.153"
 libloading = "0.7.4"

accounts-db/src/account_storage/meta.rs

@@ -128,7 +128,8 @@ impl<'storage> StoredAccountMeta<'storage> {
     pub fn hash(&self) -> &'storage AccountHash {
         match self {
             Self::AppendVec(av) => av.hash(),
-            Self::Hot(hot) => hot.hash().unwrap_or(&DEFAULT_ACCOUNT_HASH),
+            // tiered-storage has deprecated the use of AccountHash
+            Self::Hot(_) => &DEFAULT_ACCOUNT_HASH,
         }
     }
 

accounts-db/src/accounts.rs

@@ -80,11 +80,20 @@ impl AccountLocks {
             if *count == 0 {
                 occupied_entry.remove_entry();
             }
+        } else {
+            debug_assert!(
+                false,
+                "Attempted to remove a read-lock for a key that wasn't read-locked"
+            );
         }
     }
 
     fn unlock_write(&mut self, key: &Pubkey) {
-        self.write_locks.remove(key);
+        let removed = self.write_locks.remove(key);
+        debug_assert!(
+            removed,
+            "Attempted to remove a write-lock for a key that wasn't write-locked"
+        );
     }
 }
 
@@ -618,14 +627,16 @@ impl Accounts {
     #[allow(clippy::needless_collect)]
     pub fn unlock_accounts<'a>(
         &self,
-        txs: impl Iterator<Item = &'a SanitizedTransaction>,
-        results: &[Result<()>],
+        txs_and_results: impl Iterator<Item = (&'a SanitizedTransaction, &'a Result<()>)>,
     ) {
-        let keys: Vec<_> = txs
-            .zip(results)
+        let keys: Vec<_> = txs_and_results
             .filter(|(_, res)| res.is_ok())
             .map(|(tx, _)| tx.get_account_locks_unchecked())
             .collect();
+        if keys.is_empty() {
+            return;
+        }
+
         let mut account_locks = self.account_locks.lock().unwrap();
         debug!("bank unlock accounts");
         keys.into_iter().for_each(|keys| {
@@ -812,6 +823,7 @@ mod tests {
         },
         std::{
             borrow::Cow,
+            iter,
             sync::atomic::{AtomicBool, AtomicU64, Ordering},
             thread, time,
         },
@@ -1099,8 +1111,8 @@ mod tests {
 
             let txs = vec![new_sanitized_tx(&[&keypair], message, Hash::default())];
             let results = accounts.lock_accounts(txs.iter(), MAX_TX_ACCOUNT_LOCKS);
-            assert_eq!(results[0], Ok(()));
-            accounts.unlock_accounts(txs.iter(), &results);
+            assert_eq!(results, vec![Ok(())]);
+            accounts.unlock_accounts(txs.iter().zip(&results));
         }
 
         // Disallow over MAX_TX_ACCOUNT_LOCKS
@@ -1156,7 +1168,7 @@ mod tests {
         let tx = new_sanitized_tx(&[&keypair0], message, Hash::default());
         let results0 = accounts.lock_accounts([tx.clone()].iter(), MAX_TX_ACCOUNT_LOCKS);
 
-        assert!(results0[0].is_ok());
+        assert_eq!(results0, vec![Ok(())]);
         assert_eq!(
             *accounts
                 .account_locks
@@ -1190,9 +1202,13 @@ mod tests {
         let tx1 = new_sanitized_tx(&[&keypair1], message, Hash::default());
         let txs = vec![tx0, tx1];
         let results1 = accounts.lock_accounts(txs.iter(), MAX_TX_ACCOUNT_LOCKS);
-
-        assert!(results1[0].is_ok()); // Read-only account (keypair1) can be referenced multiple times
-        assert!(results1[1].is_err()); // Read-only account (keypair1) cannot also be locked as writable
+        assert_eq!(
+            results1,
+            vec![
+                Ok(()), // Read-only account (keypair1) can be referenced multiple times
+                Err(TransactionError::AccountInUse), // Read-only account (keypair1) cannot also be locked as writable
+            ],
+        );
         assert_eq!(
             *accounts
                 .account_locks
@@ -1204,8 +1220,8 @@ mod tests {
             2
         );
 
-        accounts.unlock_accounts([tx].iter(), &results0);
-        accounts.unlock_accounts(txs.iter(), &results1);
+        accounts.unlock_accounts(iter::once(&tx).zip(&results0));
+        accounts.unlock_accounts(txs.iter().zip(&results1));
         let instructions = vec![CompiledInstruction::new(2, &(), vec![0, 1])];
         let message = Message::new_with_compiled_instructions(
             1,
@@ -1217,7 +1233,10 @@ mod tests {
         );
         let tx = new_sanitized_tx(&[&keypair1], message, Hash::default());
         let results2 = accounts.lock_accounts([tx].iter(), MAX_TX_ACCOUNT_LOCKS);
-        assert!(results2[0].is_ok()); // Now keypair1 account can be locked as writable
+        assert_eq!(
+            results2,
+            vec![Ok(())] // Now keypair1 account can be locked as writable
+        );
 
         // Check that read-only lock with zero references is deleted
         assert!(accounts
@@ -1285,7 +1304,7 @@ mod tests {
                     counter_clone.clone().fetch_add(1, Ordering::SeqCst);
                 }
             }
-            accounts_clone.unlock_accounts(txs.iter(), &results);
+            accounts_clone.unlock_accounts(txs.iter().zip(&results));
             if exit_clone.clone().load(Ordering::Relaxed) {
                 break;
             }
@@ -1301,7 +1320,7 @@ mod tests {
                 thread::sleep(time::Duration::from_millis(50));
                 assert_eq!(counter_value, counter_clone.clone().load(Ordering::SeqCst));
             }
-            accounts_arc.unlock_accounts(txs.iter(), &results);
+            accounts_arc.unlock_accounts(txs.iter().zip(&results));
             thread::sleep(time::Duration::from_millis(50));
         }
         exit.store(true, Ordering::Relaxed);
@@ -1442,9 +1461,14 @@ mod tests {
             MAX_TX_ACCOUNT_LOCKS,
         );
 
-        assert!(results[0].is_ok()); // Read-only account (keypair0) can be referenced multiple times
-        assert!(results[1].is_err()); // is not locked due to !qos_results[1].is_ok()
-        assert!(results[2].is_ok()); // Read-only account (keypair0) can be referenced multiple times
+        assert_eq!(
+            results,
+            vec![
+                Ok(()), // Read-only account (keypair0) can be referenced multiple times
+                Err(TransactionError::WouldExceedMaxBlockCostLimit), // is not locked due to !qos_results[1].is_ok()
+                Ok(()), // Read-only account (keypair0) can be referenced multiple times
+            ],
+        );
 
         // verify that keypair0 read-only lock twice (for tx0 and tx2)
         assert_eq!(
@@ -1466,7 +1490,7 @@ mod tests {
             .get(&keypair2.pubkey())
             .is_none());
 
-        accounts.unlock_accounts(txs.iter(), &results);
+        accounts.unlock_accounts(txs.iter().zip(&results));
 
         // check all locks to be removed
         assert!(accounts

accounts-db/src/tiered_storage.rs

@@ -362,15 +362,15 @@ mod tests {
 
         let mut expected_accounts_map = HashMap::new();
         for i in 0..num_accounts {
-            let (account, address, account_hash, _write_version) = storable_accounts.get(i);
-            expected_accounts_map.insert(address, (account, account_hash));
+            let (account, address, _account_hash, _write_version) = storable_accounts.get(i);
+            expected_accounts_map.insert(address, account);
         }
 
         let mut index_offset = IndexOffset(0);
         let mut verified_accounts = HashSet::new();
         while let Some((stored_meta, next)) = reader.get_account(index_offset).unwrap() {
-            if let Some((account, account_hash)) = expected_accounts_map.get(stored_meta.pubkey()) {
-                verify_test_account(&stored_meta, *account, stored_meta.pubkey(), account_hash);
+            if let Some(account) = expected_accounts_map.get(stored_meta.pubkey()) {
+                verify_test_account(&stored_meta, *account, stored_meta.pubkey());
                 verified_accounts.insert(stored_meta.pubkey());
             }
             index_offset = next;

accounts-db/src/tiered_storage/byte_block.rs

@@ -95,9 +95,6 @@ impl ByteBlockWriter {
         if let Some(rent_epoch) = opt_fields.rent_epoch {
             size += self.write_pod(&rent_epoch)?;
         }
-        if let Some(hash) = opt_fields.account_hash {
-            size += self.write_pod(hash)?;
-        }
 
         debug_assert_eq!(size, opt_fields.size());
 
@@ -191,11 +188,7 @@ impl ByteBlockReader {
 
 #[cfg(test)]
 mod tests {
-    use {
-        super::*,
-        crate::accounts_hash::AccountHash,
-        solana_sdk::{hash::Hash, stake_history::Epoch},
-    };
+    use {super::*, solana_sdk::stake_history::Epoch};
 
     fn read_type_unaligned<T>(buffer: &[u8], offset: usize) -> (T, usize) {
         let size = std::mem::size_of::<T>();
@@ -352,19 +345,13 @@ mod tests {
         let mut writer = ByteBlockWriter::new(format);
         let mut opt_fields_vec = vec![];
         let mut some_count = 0;
-        let acc_hash = AccountHash(Hash::new_unique());
 
         // prepare a vector of optional fields that contains all combinations
         // of Some and None.
         for rent_epoch in [None, Some(test_epoch)] {
-            for account_hash in [None, Some(&acc_hash)] {
-                some_count += rent_epoch.iter().count() + account_hash.iter().count();
+            some_count += rent_epoch.iter().count();
 
-                opt_fields_vec.push(AccountMetaOptionalFields {
-                    rent_epoch,
-                    account_hash,
-                });
-            }
+            opt_fields_vec.push(AccountMetaOptionalFields { rent_epoch });
             test_epoch += 1;
         }
 
@@ -396,12 +383,6 @@ mod tests {
                 verified_count += 1;
                 offset += std::mem::size_of::<Epoch>();
             }
-            if let Some(expected_hash) = opt_fields.account_hash {
-                let hash = read_pod::<AccountHash>(&decoded_buffer, offset).unwrap();
-                assert_eq!(hash, expected_hash);
-                verified_count += 1;
-                offset += std::mem::size_of::<AccountHash>();
-            }
         }
 
         // make sure the number of Some fields matches the number of fields we