Dev utils tokyo 5 dm perms

program-runtime/src/stable_log.rs

@@ -22,12 +22,13 @@ pub fn program_invoke(
     program_id: &Pubkey,
     invoke_depth: usize,
 ) {
-    ic_logger_msg!(
+    /*ic_logger_msg!(
         log_collector,
         "Program {} invoke [{}]",
         program_id,
         invoke_depth
     );
+    */
 }
 
 /// Log a message from the program itself.
@@ -91,7 +92,7 @@ pub fn program_return(
 /// "Program <address> success"
 /// ```
 pub fn program_success(log_collector: &Option<Rc<RefCell<LogCollector>>>, program_id: &Pubkey) {
-    ic_logger_msg!(log_collector, "Program {} success", program_id);
+    //ic_logger_msg!(log_collector, "Program {} success", program_id);
 }
 
 /// Log program execution failure

programs/bpf_loader/src/lib.rs

@@ -228,11 +228,22 @@ pub fn create_vm<'a, 'b>(
                 .touch(index_in_transaction as IndexOfAccount)
                 .map_err(|_| ())?;
 
+            use solana_sdk::account::ReadableAccount;
+            log::warn!("cow {index_in_transaction} is_shared: {} len: {}, capacity: {}", account.is_shared(), account.data().len(), account.capacity());
             if account.is_shared() {
                 // See BorrowedAccount::make_data_mut() as to why we reserve extra
                 // MAX_PERMITTED_DATA_INCREASE bytes here.
                 account.reserve(MAX_PERMITTED_DATA_INCREASE);
+                let dst = account
+                    .spare_data_capacity_mut();
+                let mut r = 0x77;
+                for d in dst {
+                    d.write(r);
+                    r = r.wrapping_add(1);
+                }
+                //unsafe { std::ptr::write_bytes(dst, 0x77, 200) };
             }
+            log::warn!("cow {index_in_transaction} new capacity: {}", account.capacity());
             Ok(account.data_as_mut_slice().as_mut_ptr() as u64)
         })),
     )?;

programs/bpf_loader/src/syscalls/cpi.rs

@@ -22,7 +22,7 @@ fn check_account_info_pointer(
     field: &str,
 ) -> Result<(), Error> {
     if vm_addr != expected_vm_addr {
-        debug!(
+        log::warn!(
             "Invalid account info pointer `{}': {:#x} != {:#x}",
             field, vm_addr, expected_vm_addr
         );
@@ -41,6 +41,17 @@ enum VmValue<'a, 'b, T> {
 }
 
 impl<'a, 'b, T> VmValue<'a, 'b, T> {
+    fn debug(&self) -> String {
+        match self {
+            VmValue::VmAddress {
+                vm_addr,
+                memory_mapping,
+                check_aligned,
+            } => format!("VmValue::VmAddress: {vm_addr:x}"),
+            VmValue::Translated(addr) => format!("VmValue::Translated: {addr:p}"),
+        }
+    }
+
     fn get(&self) -> Result<&T, Error> {
         match self {
             VmValue::VmAddress {
@@ -1137,6 +1148,8 @@ fn cpi_common<S: SyscallInvokeSigned>(
         }
     }
 
+    log::warn!("update_caller_account loop start!");
+    defer!(log::warn!("update_caller_account loop end!"));
     for (index_in_caller, caller_account) in accounts.iter_mut() {
         if let Some(caller_account) = caller_account {
             let mut callee_account = instruction_context
@@ -1178,9 +1191,11 @@ fn update_callee_account(
         callee_account.set_lamports(*caller_account.lamports)?;
     }
 
+    let prev_len = callee_account.get_data().len();
+    let post_len = *caller_account.ref_to_len_in_vm.get()? as usize;
+    log::warn!("update_callee_account() begin! prev_len: {prev_len} post_len: {post_len} direct_mapping: {direct_mapping} {}", caller_account.ref_to_len_in_vm.debug());
+    defer!(log::warn!("update_callee_account() end!"));
     if direct_mapping {
-        let prev_len = callee_account.get_data().len();
-        let post_len = *caller_account.ref_to_len_in_vm.get()? as usize;
         match callee_account
             .can_data_be_resized(post_len)
             .and_then(|_| callee_account.can_data_be_changed())
@@ -1337,6 +1352,7 @@ fn update_caller_account(
             // memory), so that the account's memory region never points to an
             // invalid address.
             let min_capacity = caller_account.original_data_len;
+            log::warn!("callee_capacity: {} < min_capacity: {} => {}", callee_account.capacity(), min_capacity, callee_account.capacity() < min_capacity);
             if callee_account.capacity() < min_capacity {
                 callee_account.reserve(min_capacity.saturating_sub(callee_account.capacity()))?;
                 zero_all_spare_capacity = true;
@@ -1348,6 +1364,7 @@ fn update_caller_account(
             // spaces are fixed so we don't need to update the MemoryRegion's
             // length.
             let callee_ptr = callee_account.get_data().as_ptr() as u64;
+            log::warn!("region.host_addr: {}, callee_ptr: {} => {}", region.host_addr.get(), callee_ptr, region.host_addr.get() != callee_ptr);
             if region.host_addr.get() != callee_ptr {
                 region.host_addr.set(callee_ptr);
                 zero_all_spare_capacity = true;
@@ -1358,6 +1375,8 @@ fn update_caller_account(
     let prev_len = *caller_account.ref_to_len_in_vm.get()? as usize;
     let post_len = callee_account.get_data().len();
     let realloc_bytes_used = post_len.saturating_sub(caller_account.original_data_len);
+    log::warn!("update_caller_account() begin! prev_len: {prev_len} post_len: {post_len} realloc_bytes_used: {realloc_bytes_used} zero_all_spare_capacity: {zero_all_spare_capacity}! original_data_len: {}", caller_account.original_data_len);
+    defer!(log::warn!("update_caller_account() end!"));
     if prev_len != post_len {
         let max_increase = if direct_mapping && !invoke_context.get_check_aligned() {
             0
@@ -1401,15 +1420,17 @@ fn update_caller_account(
                     prev_len
                 }
                 .saturating_sub(post_len);
+                log::warn!("spare1: {:02x?}", unsafe { std::mem::transmute::<_, Option<&[u8]>>(callee_account.spare_data_capacity_mut()?.get(..50))});
                 if spare_len > 0 {
                     let dst = callee_account
                         .spare_data_capacity_mut()?
                         .get_mut(..spare_len)
                         .ok_or_else(|| Box::new(InstructionError::AccountDataTooSmall))?
                         .as_mut_ptr();
                     // Safety: we check bounds above
-                    unsafe { ptr::write_bytes(dst, 0, spare_len) };
+                    unsafe { ptr::write_bytes(dst, 0x11, spare_len) };
                 }
+                log::warn!("spare2: {:02x?}", unsafe { std::mem::transmute::<_, Option<&[u8]>>(callee_account.spare_data_capacity_mut()?.get(..50))});
 
                 // Here we zero the realloc region.
                 //
@@ -1483,6 +1504,7 @@ fn update_caller_account(
             )?;
         }
         // this is the len field in the AccountInfo::data slice
+        log::warn!("update: direct_mapping: {:?} {:?} len change: {prev_len} => {post_len}!", direct_mapping, caller_account.ref_to_len_in_vm.debug());
         *caller_account.ref_to_len_in_vm.get_mut()? = post_len as u64;
 
         // this is the len field in the serialized parameters

programs/sbf/build.rs

@@ -63,51 +63,10 @@ fn main() {
         let install_dir = "target/".to_string() + &env::var("PROFILE").unwrap() + "/sbf";
 
         let rust_programs = [
-            "128bit",
-            "alloc",
-            "alt_bn128",
-            "big_mod_exp",
-            "call_depth",
-            "caller_access",
-            "curve25519",
-            "custom_heap",
-            "dep_crate",
-            "deprecated_loader",
-            "dup_accounts",
-            "error_handling",
-            "log_data",
-            "external_spend",
-            "finalize",
-            "get_minimum_delegation",
-            "inner_instruction_alignment_check",
-            "instruction_introspection",
             "invoke",
-            "invoke_and_error",
-            "invoke_and_ok",
-            "invoke_and_return",
-            "invoked",
-            "iter",
-            "many_args",
-            "mem",
-            "membuiltins",
-            "noop",
-            "panic",
-            "param_passing",
-            "rand",
+            //"invoked",
             "realloc",
-            "realloc_invoke",
-            "ro_modify",
-            "ro_account_modify",
-            "sanity",
-            "secp256k1_recover",
-            "sha",
-            "sibling_inner_instruction",
-            "sibling_instruction",
-            "simulation",
-            "spoof1",
-            "spoof1_system",
-            "upgradeable",
-            "upgraded",
+            //"realloc_invoke",
         ];
         for program in rust_programs.iter() {
             println!("cargo:warning=(not a warning) Building Rust-based on-chain programs: solana_sbf_rust_{program}");

programs/sbf/rust/invoke/src/instructions.rs

@@ -39,6 +39,7 @@ pub const TEST_CPI_INVALID_LAMPORTS_POINTER: u8 = 36;
 pub const TEST_CPI_INVALID_DATA_POINTER: u8 = 37;
 pub const TEST_CPI_CHANGE_ACCOUNT_DATA_MEMORY_ALLOCATION: u8 = 38;
 pub const TEST_WRITE_ACCOUNT: u8 = 39;
+pub const SELF_CPI: u8 = 40;
 
 pub const MINT_INDEX: usize = 0;
 pub const ARGUMENT_INDEX: usize = 1;

programs/sbf/rust/invoke/src/processor.rs

@@ -851,56 +851,112 @@ fn process_instruction(
             let target_account = &accounts[target_account_index];
             let realloc_program_id = accounts[REALLOC_PROGRAM_INDEX].key;
             let invoke_program_id = accounts[INVOKE_PROGRAM_INDEX].key;
-            account.realloc(0, false).unwrap();
-            account.assign(realloc_program_id);
-            target_account.realloc(0, false).unwrap();
-            target_account.assign(realloc_program_id);
+            //account.realloc(0, false).unwrap();
+            //account.assign(realloc_program_id);
+            //target_account.realloc(50, false).unwrap();
+            let target_len = target_account.data.borrow().len();
+            //msg!("target realloc to {}", target_len);
+            //target_account.data.borrow_mut()[2] = 0;
+            //target_account.assign(realloc_program_id);
+            let orig_target_account_data = target_account.data.clone();
+            msg!("data+spare: {:02x?}", unsafe { slice::from_raw_parts(account.data.borrow().as_ptr(), 100) });
+            msg!("data+spare: {:02x?}", unsafe { slice::from_raw_parts(target_account.data.borrow().as_ptr(), 100) });
+            //msg!("data+spare: {:02x?}", unsafe { slice::from_raw_parts(orig_target_account_data.borrow().as_ptr(), 100) });
+            msg!("len: {}", account.data.borrow().len());
+            //msg!("len: {}", target_account.data.borrow().len());
+            //msg!("len: {}", orig_target_account_data.borrow().len());
 
             let rc_box_addr =
-                target_account.data.borrow_mut().as_mut_ptr() as *mut RcBox<RefCell<&mut [u8]>>;
-            let rc_box_size = mem::size_of::<RcBox<RefCell<&mut [u8]>>>();
+                account.data.borrow_mut().as_mut_ptr() as *mut RcBox<RefCell<&mut [u8]>>;
+            let rc_box = RcBox {
+                strong: 1,
+                weak: 0,
+                // The difference with
+                // TEST_FORBID_LEN_UPDATE_AFTER_OWNERSHIP_CHANGE_MOVING_DATA_POINTER
+                // is that we don't move the data pointer past the
+                // RcBox. This is needed to avoid the "Invalid account
+                // info pointer" check when direct mapping is enabled.
+                // This also means we don't need to update the
+                // serialized len like we do in the other test.
+                value: unsafe { RefCell::new(slice::from_raw_parts_mut(
+                    target_account.data.borrow_mut().as_mut_ptr(),
+                    target_len,
+                )) },
+            };
             unsafe {
                 std::ptr::write(
                     rc_box_addr,
-                    RcBox {
-                        strong: 1,
-                        weak: 0,
-                        // The difference with
-                        // TEST_FORBID_LEN_UPDATE_AFTER_OWNERSHIP_CHANGE_MOVING_DATA_POINTER
-                        // is that we don't move the data pointer past the
-                        // RcBox. This is needed to avoid the "Invalid account
-                        // info pointer" check when direct mapping is enabled.
-                        // This also means we don't need to update the
-                        // serialized len like we do in the other test.
-                        value: RefCell::new(slice::from_raw_parts_mut(
-                            account.data.borrow_mut().as_mut_ptr(),
-                            0,
-                        )),
-                    },
-                );
-            }
+                    rc_box,
+                )
+            };
+
+            let rc_box2 = RcBox {
+                strong: 1,
+                weak: 0,
+                // The difference with
+                // TEST_FORBID_LEN_UPDATE_AFTER_OWNERSHIP_CHANGE_MOVING_DATA_POINTER
+                // is that we don't move the data pointer past the
+                // RcBox. This is needed to avoid the "Invalid account
+                // info pointer" check when direct mapping is enabled.
+                // This also means we don't need to update the
+                // serialized len like we do in the other test.
+                value: unsafe { RefCell::new(slice::from_raw_parts_mut(
+                    target_account.data.borrow_mut().as_mut_ptr(),
+                    target_len,
+                )) },
+            };
+            let rc_box_size = mem::size_of::<RcBox<RefCell<&mut [u8]>>>();
 
             let serialized_len_ptr =
                 unsafe { account.data.borrow_mut().as_mut_ptr().offset(-8) as *mut u64 };
+            let serialized_len_ptr2 =
+                unsafe { target_account.data.borrow_mut().as_mut_ptr().offset(-8) as *mut u64 };
             // Place a RcBox<RefCell<&mut [u8]>> in the account data. This
             // allows us to test having CallerAccount::ref_to_len_in_vm in an
             // account region.
             unsafe {
                 std::ptr::write(
-                    &account.data as *const _ as usize as *mut Rc<RefCell<&mut [u8]>>,
+                    &target_account.data as *const _ as usize as *mut Rc<RefCell<&mut [u8]>>,
                     Rc::from_raw(((rc_box_addr as usize) + mem::size_of::<usize>() * 2) as *mut _),
                 );
             }
+            //msg!("ptr: {:p}", &rc_box);
+            /*
+            unsafe {
+                std::ptr::write(
+                    &account.data as *const _ as usize as *mut Rc<RefCell<&mut [u8]>>,
+                    Rc::from_raw(((&rc_box as *const _) as usize + mem::size_of::<usize>() * 2) as *mut _),
+                );
+            }
+            */
+            /*
+            unsafe {
+                std::ptr::write(
+                    &target_account.data as *const _ as usize as *mut Rc<RefCell<&mut [u8]>>,
+                    Rc::from_raw(((&rc_box as *const _) as usize + mem::size_of::<usize>() * 2) as *mut _),
+                );
+            }
+            */
+            /*
+            unsafe {
+                std::ptr::write(
+                    &target_account.data as *const _ as usize as *mut Rc<RefCell<&mut [u8]>>,
+                    Rc::from_raw(((&rc_box as *const _) as usize + mem::size_of::<usize>() * 2) as *mut _),
+                );
+            }
+            */
 
-            let mut instruction_data = vec![REALLOC, 0];
-            instruction_data.extend_from_slice(&rc_box_size.to_le_bytes());
+            let mut instruction_data = vec![SELF_CPI, 0, 0, 0];
+            //let mut instruction_data = vec![REALLOC, 0];
+            //instruction_data.extend_from_slice(&rc_box_size.to_le_bytes());
 
             // check that the account is empty before we CPI
-            assert_eq!(account.data_len(), 0);
+            //assert_eq!(account.data_len(), 0);
 
             invoke(
                 &create_instruction(
-                    *realloc_program_id,
+                    *program_id,
+                    //*realloc_program_id,
                     &[
                         (accounts[ARGUMENT_INDEX].key, true, false),
                         (target_account.key, true, false),
@@ -912,8 +968,16 @@ fn process_instruction(
                 accounts,
             )
             .unwrap();
-
-            unsafe { *serialized_len_ptr = rc_box_size as u64 };
+            msg!("CPI SUCCESS!");
+            msg!("data+spare: {:02x?}", unsafe { slice::from_raw_parts(account.data.borrow().as_ptr(), 100) });
+            msg!("data+spare: {:02x?}", unsafe { slice::from_raw_parts(target_account.data.borrow().as_ptr(), 100) });
+            //msg!("data+spare: {:02x?}", unsafe { slice::from_raw_parts(orig_target_account_data.borrow().as_ptr(), 100) });
+            msg!("len: {}", account.data.borrow().len());
+            //msg!("len: {}", target_account.data.borrow().len());
+            //msg!("len: {}", orig_target_account_data.borrow().len());
+
+            //unsafe { *serialized_len_ptr = 40 as u64 };
+            //unsafe { *serialized_len_ptr2 = rc_box_size as u64 /*+ 1*/};
             // hack to avoid dropping the RcBox, which is supposed to be on the
             // heap but we put it into account data. If we don't do this,
             // dropping the Rc will cause
@@ -925,7 +989,24 @@ fn process_instruction(
                     Rc::new(RefCell::new(&mut [])),
                 );
             }
-        }
+            unsafe {
+                std::ptr::write(
+                    &target_account.data as *const _ as usize as *mut Rc<RefCell<&mut [u8]>>,
+                    Rc::new(RefCell::new(&mut [])),
+                );
+            }
+        },
+        SELF_CPI => {
+            msg!("SELF CPI");
+            let account = &accounts[0];
+            //msg!("self-cpi-pre: {:02x?}", unsafe { slice::from_raw_parts(account.data.borrow().as_ptr(), 100) });
+            //account.data.borrow_mut()[32] = 0x99;
+            account.data.borrow_mut()[32] = 0x5;
+            //msg!("self-cpi-post: {:02x?}", unsafe { slice::from_raw_parts(account.data.borrow().as_ptr(), 100) });
+            let target_account = &accounts[1];
+            target_account.data.borrow_mut()[0] = 0x88;
+            target_account.realloc(5, false).unwrap();
+        },
         TEST_ALLOW_WRITE_AFTER_OWNERSHIP_CHANGE_TO_CALLER => {
             msg!("TEST_ALLOW_WRITE_AFTER_OWNERSHIP_CHANGE_TO_CALLER");
             const INVOKE_PROGRAM_INDEX: usize = 3;