Implement finalizer so that all locked accounts are dropped (#3585) (#3598)

* Implement finalizer so that all locked accounts are dropped when finalizer goes out of scope

* Add test for tx error with lock conflict

* Fix double unlock from destructor running after a call to unlock

runtime/src/bank.rs

@@ -5,6 +5,7 @@
 
 use crate::accounts::{Accounts, ErrorCounters, InstructionAccounts, InstructionLoaders};
 use crate::hash_queue::HashQueue;
+use crate::locked_accounts_results::LockedAccountsResults;
 use crate::runtime::{self, RuntimeError};
 use crate::status_cache::StatusCache;
 use bincode::serialize;
@@ -489,18 +490,28 @@ impl Bank {
             .map_or(Ok(()), |sig| self.get_signature_status(sig).unwrap())
     }
 
-    pub fn lock_accounts(&self, txs: &[Transaction]) -> Vec<Result<()>> {
+    pub fn lock_accounts<'a, 'b>(
+        &'a self,
+        txs: &'b [Transaction],
+    ) -> LockedAccountsResults<'a, 'b> {
         if self.is_frozen() {
             warn!("=========== FIXME: lock_accounts() working on a frozen bank! ================");
         }
         // TODO: put this assert back in
         // assert!(!self.is_frozen());
-        self.accounts().lock_accounts(self.accounts_id, txs)
+        let results = self.accounts().lock_accounts(self.accounts_id, txs);
+        LockedAccountsResults::new(results, &self, txs)
     }
 
-    pub fn unlock_accounts(&self, txs: &[Transaction], results: &[Result<()>]) {
-        self.accounts()
-            .unlock_accounts(self.accounts_id, txs, results)
+    pub fn unlock_accounts(&self, locked_accounts_results: &mut LockedAccountsResults) {
+        if locked_accounts_results.needs_unlock {
+            locked_accounts_results.needs_unlock = false;
+            self.accounts().unlock_accounts(
+                self.accounts_id,
+                locked_accounts_results.transactions(),
+                locked_accounts_results.locked_accounts_results(),
+            )
+        }
     }
 
     fn load_accounts(
@@ -512,22 +523,23 @@ impl Bank {
         self.accounts()
             .load_accounts(self.accounts_id, txs, results, error_counters)
     }
+
     fn check_age(
         &self,
         txs: &[Transaction],
-        lock_results: Vec<Result<()>>,
+        lock_results: &LockedAccountsResults,
         max_age: usize,
         error_counters: &mut ErrorCounters,
     ) -> Vec<Result<()>> {
         let hash_queue = self.blockhash_queue.read().unwrap();
         txs.iter()
-            .zip(lock_results.into_iter())
+            .zip(lock_results.locked_accounts_results())
             .map(|(tx, lock_res)| {
                 if lock_res.is_ok() && !hash_queue.check_entry_age(tx.recent_blockhash, max_age) {
                     error_counters.reserve_blockhash += 1;
                     Err(BankError::BlockhashNotFound)
                 } else {
-                    lock_res
+                    lock_res.clone()
                 }
             })
             .collect()
@@ -560,7 +572,7 @@ impl Bank {
     pub fn load_and_execute_transactions(
         &self,
         txs: &[Transaction],
-        lock_results: Vec<Result<()>>,
+        lock_results: &LockedAccountsResults,
         max_age: usize,
     ) -> (
         Vec<Result<(InstructionAccounts, InstructionLoaders)>>,
@@ -718,7 +730,7 @@ impl Bank {
     pub fn load_execute_and_commit_transactions(
         &self,
         txs: &[Transaction],
-        lock_results: Vec<Result<()>>,
+        lock_results: &LockedAccountsResults,
         max_age: usize,
     ) -> Vec<Result<()>> {
         let (loaded_accounts, executed) =
@@ -730,10 +742,7 @@ impl Bank {
     #[must_use]
     pub fn process_transactions(&self, txs: &[Transaction]) -> Vec<Result<()>> {
         let lock_results = self.lock_accounts(txs);
-        let results =
-            self.load_execute_and_commit_transactions(txs, lock_results, MAX_RECENT_BLOCKHASHES);
-        self.unlock_accounts(txs, &results);
-        results
+        self.load_execute_and_commit_transactions(txs, &lock_results, MAX_RECENT_BLOCKHASHES)
     }
 
     /// Create, sign, and process a Transaction from `keypair` to `to` of
@@ -1291,7 +1300,7 @@ mod tests {
         let lock_result = bank.lock_accounts(&pay_alice);
         let results_alice = bank.load_execute_and_commit_transactions(
             &pay_alice,
-            lock_result,
+            &lock_result,
             MAX_RECENT_BLOCKHASHES,
         );
         assert_eq!(results_alice[0], Ok(()));
@@ -1308,7 +1317,7 @@ mod tests {
             Err(BankError::AccountInUse)
         );
 
-        bank.unlock_accounts(&pay_alice, &results_alice);
+        drop(lock_result);
 
         assert!(bank
             .transfer(2, &mint_keypair, &bob.pubkey(), genesis_block.hash())

runtime/src/lib.rs

@@ -4,6 +4,7 @@ pub mod bank;
 pub mod bloom;
 mod hash_queue;
 pub mod loader_utils;
+pub mod locked_accounts_results;
 mod native_loader;
 pub mod runtime;
 mod status_cache;

runtime/src/locked_accounts_results.rs

@@ -0,0 +1,42 @@
+use crate::bank::{Bank, Result};
+use solana_sdk::transaction::Transaction;
+
+// Represents the results of trying to lock a set of accounts
+pub struct LockedAccountsResults<'a, 'b> {
+    locked_accounts_results: Vec<Result<()>>,
+    bank: &'a Bank,
+    transactions: &'b [Transaction],
+    pub(crate) needs_unlock: bool,
+}
+
+impl<'a, 'b> LockedAccountsResults<'a, 'b> {
+    pub fn new(
+        locked_accounts_results: Vec<Result<()>>,
+        bank: &'a Bank,
+        transactions: &'b [Transaction],
+    ) -> Self {
+        Self {
+            locked_accounts_results,
+            bank,
+            transactions,
+            needs_unlock: true,
+        }
+    }
+
+    pub fn locked_accounts_results(&self) -> &Vec<Result<()>> {
+        &self.locked_accounts_results
+    }
+
+    pub fn transactions(&self) -> &[Transaction] {
+        self.transactions
+    }
+}
+
+// Unlock all locked accounts in destructor.
+impl<'a, 'b> Drop for LockedAccountsResults<'a, 'b> {
+    fn drop(&mut self) {
+        if self.needs_unlock {
+            self.bank.unlock_accounts(self)
+        }
+    }
+}