Retain alloc'd and updated data in cpi (#16850)

programs/bpf/rust/invoke/src/lib.rs

@@ -374,6 +374,32 @@ fn process_instruction(
                     accounts[INVOKED_ARGUMENT_INDEX].data.borrow_mut()[..NUM_BYTES]
                 );
             }
+
+            msg!("Create account and init data");
+            {
+                let from_lamports = accounts[FROM_INDEX].lamports();
+                let to_lamports = accounts[DERIVED_KEY2_INDEX].lamports();
+
+                let instruction = create_instruction(
+                    *accounts[INVOKED_PROGRAM_INDEX].key,
+                    &[
+                        (accounts[FROM_INDEX].key, true, true),
+                        (accounts[DERIVED_KEY2_INDEX].key, true, false),
+                        (accounts[SYSTEM_PROGRAM_INDEX].key, false, false),
+                    ],
+                    vec![CREATE_AND_INIT, bump_seed2],
+                );
+                invoke(&instruction, accounts)?;
+
+                assert_eq!(accounts[FROM_INDEX].lamports(), from_lamports - 1);
+                assert_eq!(accounts[DERIVED_KEY2_INDEX].lamports(), to_lamports + 1);
+                let data = accounts[DERIVED_KEY2_INDEX].try_borrow_mut_data()?;
+                assert_eq!(data[0], 0x0e);
+                assert_eq!(data[MAX_PERMITTED_DATA_INCREASE - 1], 0x0f);
+                for i in 1..20 {
+                    assert_eq!(data[i], i as u8);
+                }
+            }
         }
         TEST_PRIVILEGE_ESCALATION_SIGNER => {
             msg!("Test privilege escalation signer");

programs/bpf/rust/invoked/src/instruction.rs

@@ -17,6 +17,7 @@ pub const VERIFY_PRIVILEGE_DEESCALATION: u8 = 8;
 pub const VERIFY_PRIVILEGE_DEESCALATION_ESCALATION_SIGNER: u8 = 9;
 pub const VERIFY_PRIVILEGE_DEESCALATION_ESCALATION_WRITABLE: u8 = 10;
 pub const WRITE_ACCOUNT: u8 = 11;
+pub const CREATE_AND_INIT: u8 = 12;
 
 pub fn create_instruction(
     program_id: Pubkey,

programs/bpf/rust/invoked/src/processor.rs

@@ -6,11 +6,12 @@ use crate::instruction::*;
 use solana_program::{
     account_info::AccountInfo,
     bpf_loader, entrypoint,
-    entrypoint::ProgramResult,
+    entrypoint::{ProgramResult, MAX_PERMITTED_DATA_INCREASE},
     msg,
     program::{invoke, invoke_signed},
     program_error::ProgramError,
     pubkey::Pubkey,
+    system_instruction,
 };
 
 entrypoint!(process_instruction);
@@ -236,6 +237,52 @@ fn process_instruction(
                 accounts[ARGUMENT_INDEX].data.borrow_mut()[i as usize] = instruction_data[1];
             }
         }
+        CREATE_AND_INIT => {
+            msg!("Create and init data");
+            {
+                const FROM_INDEX: usize = 0;
+                const DERIVED_KEY2_INDEX: usize = 1;
+
+                let from_lamports = accounts[FROM_INDEX].lamports();
+                let to_lamports = accounts[DERIVED_KEY2_INDEX].lamports();
+                assert_eq!(accounts[DERIVED_KEY2_INDEX].data_len(), 0);
+                assert!(solana_program::system_program::check_id(
+                    accounts[DERIVED_KEY2_INDEX].owner
+                ));
+
+                let bump_seed2 = instruction_data[1];
+                let instruction = system_instruction::create_account(
+                    accounts[FROM_INDEX].key,
+                    accounts[DERIVED_KEY2_INDEX].key,
+                    1,
+                    MAX_PERMITTED_DATA_INCREASE as u64,
+                    program_id,
+                );
+                invoke_signed(
+                    &instruction,
+                    accounts,
+                    &[&[b"Lil'", b"Bits", &[bump_seed2]]],
+                )?;
+
+                assert_eq!(accounts[FROM_INDEX].lamports(), from_lamports - 1);
+                assert_eq!(accounts[DERIVED_KEY2_INDEX].lamports(), to_lamports + 1);
+                assert_eq!(program_id, accounts[DERIVED_KEY2_INDEX].owner);
+                assert_eq!(
+                    accounts[DERIVED_KEY2_INDEX].data_len(),
+                    MAX_PERMITTED_DATA_INCREASE
+                );
+                let mut data = accounts[DERIVED_KEY2_INDEX].try_borrow_mut_data()?;
+                assert_eq!(data[0], 0);
+                data[0] = 0x0e;
+                assert_eq!(data[0], 0x0e);
+                assert_eq!(data[MAX_PERMITTED_DATA_INCREASE - 1], 0);
+                data[MAX_PERMITTED_DATA_INCREASE - 1] = 0x0f;
+                assert_eq!(data[MAX_PERMITTED_DATA_INCREASE - 1], 0x0f);
+                for i in 1..20 {
+                    data[i] = i as u8;
+                }
+            }
+        }
         _ => panic!(),
     }
 

programs/bpf/tests/programs.rs

@@ -876,6 +876,8 @@ fn test_program_bpf_invoke_sanity() {
                 invoked_program_id.clone(),
                 invoked_program_id.clone(),
                 invoked_program_id.clone(),
+                invoked_program_id.clone(),
+                solana_sdk::system_program::id(),
             ],
         };
         assert_eq!(invoked_programs.len(), expected_invoked_programs.len());