Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit f2f47312 authored by Android Build Coastguard Worker's avatar Android Build Coastguard Worker
Browse files

Snap for 11822896 from d81c41d0 to 24Q3-release 

Change-Id: Ibbcf7e72d04f239f43aaad3e367380e3a68477f7
parents 596e8963 d81c41d0

audio/aidl/default/Stream.cpp

+9 −2
Original line number Diff line number Diff line
@@ -315,7 +315,11 @@ StreamInWorkerLogic::Status StreamInWorkerLogic::cycle() { 
bool StreamInWorkerLogic::read(size_t clientSize, StreamDescriptor::Reply* reply) {

    ATRACE_CALL();

    StreamContext::DataMQ* const dataMQ = mContext->getDataMQ();

    const size_t byteCount = std::min({clientSize, dataMQ->availableToWrite(), mDataBufferSize});

    StreamContext::DataMQ::Error fmqError = StreamContext::DataMQ::Error::NONE;

    std::string fmqErrorMsg;

    const size_t byteCount = std::min(

            {clientSize, dataMQ->availableToWrite(&fmqError, &fmqErrorMsg), mDataBufferSize});

    CHECK(fmqError == StreamContext::DataMQ::Error::NONE) << fmqErrorMsg;

    const bool isConnected = mIsConnected;

    const size_t frameSize = mContext->getFrameSize();

    size_t actualFrameCount = 0;
@@ -587,7 +591,10 @@ StreamOutWorkerLogic::Status StreamOutWorkerLogic::cycle() { 
bool StreamOutWorkerLogic::write(size_t clientSize, StreamDescriptor::Reply* reply) {

    ATRACE_CALL();

    StreamContext::DataMQ* const dataMQ = mContext->getDataMQ();

    const size_t readByteCount = dataMQ->availableToRead();

    StreamContext::DataMQ::Error fmqError = StreamContext::DataMQ::Error::NONE;

    std::string fmqErrorMsg;

    const size_t readByteCount = dataMQ->availableToRead(&fmqError, &fmqErrorMsg);

    CHECK(fmqError == StreamContext::DataMQ::Error::NONE) << fmqErrorMsg;

    const size_t frameSize = mContext->getFrameSize();

    bool fatal = false;

    int32_t latency = mContext->getNominalLatencyMs();

radio/aidl/vts/radio_network_test.cpp

+25 −0
Original line number Diff line number Diff line
@@ -2195,6 +2195,18 @@ TEST_P(RadioNetworkTest, triggerEmergencyNetworkScan) { 


    serial = GetRandomSerialNumber();



    radio_network->setEmergencyMode(serial, EmergencyMode::EMERGENCY_WWAN);

    EXPECT_EQ(std::cv_status::no_timeout, wait());

    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);

    EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);



    ASSERT_TRUE(CheckAnyOfErrors(

            radioRsp_network->rspInfo.error,

            {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED, RadioError::RADIO_NOT_AVAILABLE,

             RadioError::MODEM_ERR, RadioError::INVALID_ARGUMENTS}));



    serial = GetRandomSerialNumber();



    EmergencyNetworkScanTrigger scanRequest;

    scanRequest.accessNetwork = {AccessNetwork::EUTRAN};

    scanRequest.scanType = EmergencyScanType::NO_PREFERENCE;
@@ -2208,6 +2220,19 @@ TEST_P(RadioNetworkTest, triggerEmergencyNetworkScan) { 
            radioRsp_network->rspInfo.error,

            {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED, RadioError::RADIO_NOT_AVAILABLE,

             RadioError::MODEM_ERR, RadioError::INVALID_ARGUMENTS}));



    // exit emergency mode for other tests

    serial = GetRandomSerialNumber();



    radio_network->exitEmergencyMode(serial);



    EXPECT_EQ(std::cv_status::no_timeout, wait());

    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);

    EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);



    ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,

                                 {RadioError::NONE, RadioError::REQUEST_NOT_SUPPORTED,

                                  RadioError::RADIO_NOT_AVAILABLE, RadioError::MODEM_ERR}));

}



/*

security/keymint/aidl/default/main.rs

+29 −31
Original line number Diff line number Diff line
@@ -74,6 +74,35 @@ fn inner_main() -> Result<(), HalServiceError> { 
    // Create a TA in-process, which acts as a local channel for communication.

    let channel = Arc::new(Mutex::new(LocalTa::new()));



    // Let the TA know information about the boot environment. In a real device this

    // is communicated directly from the bootloader to the TA, but here we retrieve

    // the information from system properties and send from the HAL service.

    let boot_req = get_boot_info();

    debug!("boot/HAL->TA: boot info is {:?}", boot_req);

    kmr_hal::send_boot_info(channel.lock().unwrap().deref_mut(), boot_req)

        .map_err(|e| HalServiceError(format!("Failed to send boot info: {:?}", e)))?;



    // Let the TA know information about the userspace environment.

    if let Err(e) = kmr_hal::send_hal_info(channel.lock().unwrap().deref_mut()) {

        error!("Failed to send HAL info: {:?}", e);

    }



    // Let the TA know about attestation IDs. (In a real device these would be pre-provisioned into

    // the TA.)

    let attest_ids = attestation_id_info();

    if let Err(e) = kmr_hal::send_attest_ids(channel.lock().unwrap().deref_mut(), attest_ids) {

        error!("Failed to send attestation ID info: {:?}", e);

    }



    let secret_service = kmr_hal::sharedsecret::Device::new_as_binder(channel.clone());

    let service_name = format!("{}/{}", SECRET_SERVICE_NAME, SERVICE_INSTANCE);

    binder::add_service(&service_name, secret_service.as_binder()).map_err(|e| {

        HalServiceError(format!(

            "Failed to register service {} because of {:?}.",

            service_name, e

        ))

    })?;



    let km_service = kmr_hal::keymint::Device::new_as_binder(channel.clone());

    let service_name = format!("{}/{}", KM_SERVICE_NAME, SERVICE_INSTANCE);

    binder::add_service(&service_name, km_service.as_binder()).map_err(|e| {
@@ -101,37 +130,6 @@ fn inner_main() -> Result<(), HalServiceError> { 
        ))

    })?;



    let secret_service = kmr_hal::sharedsecret::Device::new_as_binder(channel.clone());

    let service_name = format!("{}/{}", SECRET_SERVICE_NAME, SERVICE_INSTANCE);

    binder::add_service(&service_name, secret_service.as_binder()).map_err(|e| {

        HalServiceError(format!(

            "Failed to register service {} because of {:?}.",

            service_name, e

        ))

    })?;



    info!("Successfully registered KeyMint HAL services.");



    // Let the TA know information about the boot environment. In a real device this

    // is communicated directly from the bootloader to the TA, but here we retrieve

    // the information from system properties and send from the HAL service.

    let boot_req = get_boot_info();

    debug!("boot/HAL->TA: boot info is {:?}", boot_req);

    kmr_hal::send_boot_info(channel.lock().unwrap().deref_mut(), boot_req)

        .map_err(|e| HalServiceError(format!("Failed to send boot info: {:?}", e)))?;



    // Let the TA know information about the userspace environment.

    if let Err(e) = kmr_hal::send_hal_info(channel.lock().unwrap().deref_mut()) {

        error!("Failed to send HAL info: {:?}", e);

    }



    // Let the TA know about attestation IDs. (In a real device these would be pre-provisioned into

    // the TA.)

    let attest_ids = attestation_id_info();

    if let Err(e) = kmr_hal::send_attest_ids(channel.lock().unwrap().deref_mut(), attest_ids) {

        error!("Failed to send attestation ID info: {:?}", e);

    }



    info!("Successfully registered KeyMint HAL services.");

    binder::ProcessState::join_thread_pool();

    info!("KeyMint HAL service is terminating."); // should not reach here