// ---------------------------------------------------------------------------
// CLingerConnection::StartTimer()
// ---------------------------------------------------------------------------
//
void CLingerConnection::StartTimer( TInt aTimerInterval, TBool aReset )
{
LOG_1( _L("CLingerConnection::StartTimer") );
if ( aReset )
{
iLingerTimerCount = 0;
}
TCallBack cb( TimerCallBack, this );
// if linger timer is negative we should not start timer but linger forever...
if ( iLingerInterval > 0 )
{
LOG_2( _L("iTimer->Start: aTimerInterval: %d"), aTimerInterval );
if( aTimerInterval > KMaxTimerInSeconds )
{
// Maximum allowed interval is 30 minutes.
// This restriction comes from TTimeIntervalMicroSeconds32
iCurrentTimerInterval = KMaxTimerInSeconds;
}
else
{
// use current value
iCurrentTimerInterval = aTimerInterval;
}
LOG_2( _L("iTimer->Start: iCurrentTimerInterval: %d"), iCurrentTimerInterval );
CancelTimer();
iTimer->Start( ( iCurrentTimerInterval * KSecondsToMicro ),
( iCurrentTimerInterval * KSecondsToMicro ),
cb );
}
}
// ---------------------------------------------------------------------------
// CAOConnectionImpl::FailureReason
// ---------------------------------------------------------------------------
//
MAOConnectionManager::TFailureReason CAOConnectionImpl::FailureReason(
TInt aError )
{
LOG_2( _L("CAOConnectionImpl::FailureReason: aError: %d"), aError );
// Determine error cause
MAOConnectionManager::TFailureReason reason =
MAOConnectionManager::EPermanent;
switch ( aError )
{
// Temporary cause
case KErrGprsUserAuthenticationFailure:
case KErrGprsActivationRejectedByGGSN:
case KErrGprsActivationRejected:
case KErrGprsServiceOptionTemporarilyOutOfOrder:
{
reason = MAOConnectionManager::ETemporary;
break;
}
// Permanent cause
default:
{
reason = MAOConnectionManager::EPermanent;
break;
}
}
LOG_2( _L("CAOConnectionImpl::FailureReason: Reason: %d"), reason );
return reason;
}
// ---------------------------------------------------------------------------
// CAOSettings::UpdateIAPSetting
// ---------------------------------------------------------------------------
//
void CAOSettings::UpdateIAPSetting()
{
LOG_2( _L("CAOSettings::UpdateIAPSettingL >> Old value: %d"), iIAP );
UpdateSetting( KPDPContextManagerDefaultUid, iIAP );
LOG_2( _L("CAOSettings::UpdateIAPSettingL >> New value: %d"), iIAP );
}
// ---------------------------------------------------------------------------
// CAOSettings::UpdateUnconnectTimerSetting
// ---------------------------------------------------------------------------
//
void CAOSettings::UpdateUnconnectTimerSetting()
{
LOG_2( _L("CAOSettings::UpdateUnconnectTimerSetting >> Old value: %d"),
iUnconnectTimerValue );
UpdateSetting( KPDPContextManagerUnconnectTimer, iUnconnectTimerValue );
LOG_2( _L("CAOSettings::UpdateUnconnectTimerSetting >> New value: %d"),
iUnconnectTimerValue );
}
// ---------------------------------------------------------------------------
// CAOSettings::UpdateRetryTimerSetting
// ---------------------------------------------------------------------------
//
void CAOSettings::UpdateRetryTimerSetting()
{
LOG_2( _L("CAOSettings::UpdateRetryTimerSetting >> Old value: %d"),
iRetryTimerValue );
UpdateSetting( KPDPContextManagerRetryTimer, iRetryTimerValue );
LOG_2( _L("CAOSettings::UpdateRetryTimerSetting >> New value: %d"),
iRetryTimerValue );
}
// ---------------------------------------------------------------------------
// CAOSettings::UpdateVPLMNSetting
// ---------------------------------------------------------------------------
//
void CAOSettings::UpdateVPLMNSetting()
{
LOG_2( _L("CAOSettings::UpdateVPLMNSetting >> Old value: %d"),
iSupportedInVPLMN );
UpdateSetting( KPDPContextManagerEnableWhenRoaming, iSupportedInVPLMN );
LOG_2( _L("CAOSettings::UpdateVPLMNSetting >> New value: %d"),
iSupportedInVPLMN );
}
// ---------------------------------------------------------------------------
// TAOStateStarting::StateName
// ---------------------------------------------------------------------------
//
TAOState::TAOStateName TAOStateStarting::StateName() const
{
LOG_2( _L("TAOStateStarting::StateName: %d"),
TAOState::EStateStarting );
return TAOState::EStateStarting;
}
// ---------------------------------------------------------------------------
// CAOSettings::HandleNotifyGeneric
// ---------------------------------------------------------------------------
//
void CAOSettings::HandleNotifyGeneric( TUint32 aId )
{
LOG_2( _L("CAOSettings::HandleNotifyGeneric: aId: %d"), aId );
switch ( aId )
{
// We are interested only in Always-On settings
case KPDPContextManagerDefaultUid:
case KPDPContextManagerRetryTimer:
case KPDPContextManagerConnectionTimer:
case KPDPContextManagerUnconnectTimer:
case KPDPContextManagerEnableWhenRoaming:
case KPDPContextManagerEnableWhenHome:
{
FetchSettings( aId );
break;
}
default:
{
if ( ( aId & KLingerColumn ) == KLingerColumn )
{
FetchSettings( KPDPContextManagerLinger );
}
break;
}
}
}
// ---------------------------------------------------------------------------
// CAOSettings::LingerTimerValue
// ---------------------------------------------------------------------------
//
TInt CAOSettings::LingerTimerValue( const TUint aIapId ) const
{
LOG_1( _L("CAOSettings::LingerTimerValue") );
for ( TInt j=0; j < iLingerSettings.Count(); j++ )
{
if ( iLingerSettings[ j ].iIap == aIapId )
{
LOG_3( _L("Linger setting found >> iap: %d, interval: %d"),
aIapId,
iLingerSettings[ j ].iInterval);
if ( iLingerSettings[ j ].iInterval == 0 )
{
return KLingerForEver;
}
else
{
return ( iLingerSettings[ j ].iInterval );
}
}
}
LOG_2( _L("LingerTimerValue() not found >> iap: %d"),
aIapId );
return KLingerOff; // Linger is off
}
// ---------------------------------------------------------------------------
// CAOConnectionImpl::RunL
// ---------------------------------------------------------------------------
//
void CAOConnectionImpl::RunL()
{
LOG_2( _L("CAOConnectionImpl::RunL: iStatus: %d"), iStatus.Int() );
TInt status = iStatus.Int();
switch ( iState )
{
case EDisconnected:
{
// Nothing to do
break;
}
case EOpeningLink:
{
HandleOpeningLinkL( status );
break;
}
case EListeningAccessPoint:
{
HandleListeningAccessPointL( status );
break;
}
case EAttachingExistingConnection:
{
HandleAttachingExistingConnectionL( status );
break;
}
default:
{
// Should not be here
Panic( EInvalidState );
break;
}
}
}
// ---------------------------------------------------------------------------
// CLingerConnection::StartLinger
// ---------------------------------------------------------------------------
//
TInt CLingerConnection::StartLinger()
{
LOG_1( _L("CLingerConnection::StartLinger") );
if ( !iAttached )
{
// Read settings
ReadSettings();
if ( iLingerInterval != 0 )
{
TInt err = OpenAndAttach();
if ( err != KErrNone )
{
// Write to log
LOG_2( _L("OpenAndAttach: err: %d"), err );
return( err );
}
if ( iLingerInterval > 0 )
{
// Start timer
StartTimer( KDataInactivityInterval );
LOG_1( _L("Linger timer started OK") );
}
}
}
return KErrNone;
}
// ---------------------------------------------------------------------------
// CAOSettings::RunL
// ---------------------------------------------------------------------------
//
void CAOSettings::RunL()
{
LOG_2( _L("CAOSettings::RunL: iStatus: %d"), iStatus.Int() );
// Currently we cannot complete with an error
SetupSettings( iSettingsToFetch );
iObserver.HandleSettingsChangedL();
}
// ---------------------------------------------------------------------------
// CAOGpds::RunL
// ---------------------------------------------------------------------------
//
void CAOGpds::RunL()
{
LOG_2( _L("CAOGpds::RunL: iStatus: %d"), iStatus.Int() );
if ( iWait->IsStarted() )
{
iWait->AsyncStop();
}
}
// ---------------------------------------------------------------------------
// CLingerConnection::IsConnectionIdle
// ---------------------------------------------------------------------------
//
TBool CLingerConnection::IsConnectionIdle()
{
LOG_1( _L("CLingerConnection::IsConnectionIdle") );
TUint currentDlData( iDlData );
TUint currentUlData( iUlData );
if ( !iAttached )
{
return ETrue;
}
LOG_2( _L("old Uplink data volume: %d"), currentUlData );
LOG_2( _L("old Downlink data volume: %d"), currentDlData );
// get new data volumes from ESock
iDlData = 0;
iUlData = 0;
TRequestStatus status( KErrNone );
iConnection.DataTransferredRequest( iPckgUlData, iPckgDlData, status );
User::WaitForRequest( status );
LOG_2( _L("new Uplink data volume: %d"), iUlData );
LOG_2( _L("new Downlink data volume: %d"), iDlData );
if ( status == KErrNone )
{
if ( ( iUlData == currentUlData ) && ( iDlData == currentDlData ) )
{
return ETrue;
}
else
{
return EFalse;
}
}
else
{
return EFalse;
}
}
// ---------------------------------------------------------------------------
// CAOConnectionImpl::CompleteSelf
// ---------------------------------------------------------------------------
//
void CAOConnectionImpl::CompleteSelf( TRequestStatus& aStatus, TInt aReason )
{
LOG_2( _L("CAOConnectionImpl::CompleteSelf: aReason: %d"), aReason );
__ASSERT_DEBUG( IsActive(), Panic( ENotActive ) );
aStatus = KRequestPending;
TRequestStatus* status = &aStatus;
User::RequestComplete( status, aReason );
}
// ---------------------------------------------------------------------------
// CAOSettings::SetupSettings
// ---------------------------------------------------------------------------
//
void CAOSettings::SetupSettings( TUint32 aId )
{
LOG_2( _L("CAOSettings::SetupSettings: aId: %d"), aId );
switch ( aId )
{
case KPDPContextManagerDefaultUid:
{
UpdateIAPSetting();
break;
}
case KPDPContextManagerRetryTimer:
{
UpdateRetryTimerSetting();
break;
}
case KPDPContextManagerConnectionTimer:
{
UpdateConnectionTimerSetting();
break;
}
case KPDPContextManagerUnconnectTimer:
{
UpdateUnconnectTimerSetting();
break;
}
case KPDPContextManagerEnableWhenHome:
{
UpdateHPLMNSetting();
break;
}
case KPDPContextManagerEnableWhenRoaming:
{
UpdateVPLMNSetting();
break;
}
case KPDPContextManagerLinger:
{
UpdateLingerTimerSetting();
break;
}
default:
{
// Set all
UpdateIAPSetting();
UpdateRetryTimerSetting();
UpdateConnectionTimerSetting();
UpdateUnconnectTimerSetting();
UpdateHPLMNSetting();
UpdateVPLMNSetting();
UpdateLingerTimerSetting();
break;
}
}
}
// ---------------------------------------------------------------------------
// CAOSettings::FetchSettings
// ---------------------------------------------------------------------------
//
void CAOSettings::FetchSettings( TUint32 aId )
{
LOG_2( _L("CAOSettings::FetchSettings: aId: %d"), aId );
__ASSERT_DEBUG( !IsActive(), Panic( EAlreadyFetchingSettings ) );
// Let just scheduler run and get settings when RunL is called
iSettingsToFetch = aId;
iStatus = KRequestPending;
SetActive();
CompleteSelf( iStatus, KErrNone );
}
// ---------------------------------------------------------------------------
// CAOSettings::UpdateSetting
// ---------------------------------------------------------------------------
//
void CAOSettings::UpdateSetting( TUint32 aId, TInt& aValue )
{
LOG_2( _L("CAOSettings::UpdateSetting: %d"), aId );
TInt value = 0;
TInt err = iRepository->Get( aId, value );
if ( err == KErrNone )
{
// New value got, store it
aValue = value;
}
}
TAOState* TAOState::HandleNetworkChangedL(
MAOConnectionManager::TNetworkType /*aNetworkType*/ )
#endif
{
LOG_2( _L("TAOState::HandleNetworkChangedL: aNetworkType: %d"),
aNetworkType );
// PLMN change notification
// Cancel all requests
CancelAll();
return iStatePool.ChangeState( EStateStarting );
}
// ---------------------------------------------------------------------------
// CAOSettings::UpdateLingerTimerSetting
// ---------------------------------------------------------------------------
//
void CAOSettings::UpdateLingerTimerSetting()
{
LOG_1( _L("CAOSettings::UpdateLingerTimerSetting"));
TInt count( 0 );
TInt err( KErrNone );
TLingerSetting ls;
iLingerSettings.Reset();
// Get number of entries (iapId&linger) in Centrep
err = iRepository->Get( KPdpContextManagerLingerArrayCount, count );
if ( err == KErrNone )
{
// read all entries from Centrep
for ( TInt row=1; row <= count; row++ )
{
err = iRepository->Get( ( KIapColumn | row ), ls.iIap );
if ( err == KErrNone )
{
err = iRepository->Get( ( KLingerColumn | row ), ls.iInterval );
}
if ( err == KErrNone )
{
iLingerSettings.Append( ls );
}
else
{
LOG_3( _L("CRepository::Get() failed >> err: %d, row: %d"),
err, row);
return;
}
}
}
else
{
LOG_2( _L("CRepository::Get( KPdpContextManagerLingerArrayCount) >> err: %d"),
err);
}
// Write to log
for ( TInt j=0; j < iLingerSettings.Count(); j++ )
{
LOG_3( _L("iLingerSettings >> iap: %d, interval: %d"),
iLingerSettings[ j ].iIap,
iLingerSettings[ j ].iInterval);
}
}
// ---------------------------------------------------------------------------
// CAOConnectionImpl::HandleOpeningLinkL
// ---------------------------------------------------------------------------
//
void CAOConnectionImpl::HandleOpeningLinkL( TInt aStatus )
{
LOG_2( _L("CAOConnectionImpl::HandleOpeningLinkL: aStatus: %d"),
aStatus );
if ( aStatus == KErrNone )
{
// Everything ok - Link opened
BroadcastPDPContextActivatedL();
}
else
{
// Report error
BroadcastPDPContextActivationFailureL( aStatus );
}
}
// ---------------------------------------------------------------------------
// CAOConnectionImpl::HandleListeningAccessPointL
// ---------------------------------------------------------------------------
//
void CAOConnectionImpl::HandleListeningAccessPointL( TInt aStatus )
{
LOG_2( _L("CAOConnectionImpl::HandleListeningAccessPointL: aStatus: %d"),
aStatus );
if ( aStatus == KErrNone )
{
// Everything ok - Continue listening
iStatus = KRequestPending;
SetActive();
}
else
{
// Report error
BroadcastPDPContextDisconnectionL( aStatus );
}
}
// ---------------------------------------------------------------------------
// CAOTimer::ConfigureInterval
// ---------------------------------------------------------------------------
//
TInt CAOTimer::ConfigureInterval( const TInt& aIntervalInSec )
{
LOG_2( _L("CAOTimer::ConfigureInterval: aIntervalInSec: %d"),
aIntervalInSec );
// Interval maximum value is 30 minutes
TInt interval = 0;
if( aIntervalInSec > KMaxTimerInSeconds )
{
interval = KMaxTimerInSeconds * KSecondsToMicro;
}
else
{
interval = aIntervalInSec * KSecondsToMicro;
}
return interval;
}
// --------------------------------------------------------------------------
// TAOState::EnableAlwaysOn
// --------------------------------------------------------------------------
//
TBool TAOState::EnableAlwaysOn()
{
LOG_1( _L("TAOState::EnableAlwaysOn") );
TBool enabled = EFalse;
MAOConnectionManager& connectionManager =
iStateContext.ConnectionManager();
MAOSettings& settings = iStateContext.Settings();
// If new state is in starting state, we'll check
// whether Always-On should be supported in current
// network
MAOConnectionManager::TNetworkType nwType =
connectionManager.NetworkType();
switch ( nwType )
{
case MAOConnectionManager::EHPLMN:
{
if ( settings.AlwaysOnSupportedInHPLMN() )
{
enabled = ETrue;
}
break;
}
case MAOConnectionManager::EVPLMN:
{
if ( settings.AlwaysOnSupportedInVPLMN() )
{
enabled = ETrue;
}
break;
}
default:
{
// Not enabled
break;
}
}
LOG_2( _L("TAOState::EnableAlwaysOn >> Enabled: %d"), enabled );
return enabled;
}
// ---------------------------------------------------------------------------
// CAOConnectionImpl::PDPContextDisconnectionRunL
// ---------------------------------------------------------------------------
//
void CAOConnectionImpl::PDPContextDisconnectionRunL( TInt aStatus )
{
LOG_2( _L("CAOConnectionImpl::PDPContextDisconnectionRunL: aStatus: %d"),
aStatus );
if ( aStatus == KErrNone )
{
TInt value = 0;
TInt err = iPDPContextDisconnectionProperty.Get( value );
if ( err == KErrNone )
{
iDisconnectionError = value;
if ( IsActive() && iState == EListeningAccessPoint )
{
CompleteSelf( iStatus, iDisconnectionError );
}
}
}
SubscribePDPContextDisconnection();
}
// ---------------------------------------------------------------------------
// CAORAUManagerImpl::RAUEventSubscribeRunL
// ---------------------------------------------------------------------------
//
void CAORAUManagerImpl::RAUEventSubscribeRunL( TInt aStatus )
{
LOG_2( _L("CAORAUManagerImpl::RAUEventSubscribeRunL: aStatus: %d"),
aStatus );
if ( aStatus == KErrNone )
{
TInt value = 0;
TInt err = iRAUEventProperty.Get( value );
if ( err == KErrNone )
{
MAORAUManagerObserver::TRAUType rauType =
MAORAUManagerObserver::ENormal;
if ( value == EPeriodicalRAU )
{
rauType = MAORAUManagerObserver::EPeriodical;
}
iObserver.HandleSuccesfulRAUL( rauType );
}
}
SubscribeRAUEvents();
}
// ---------------------------------------------------------------------------
// CAOSettings::IsCellularAllowedByUser
// ---------------------------------------------------------------------------
//
TBool CAOSettings::IsCellularAllowedByUser() const
{
TBool allowed( ETrue );
CRepository* repository = NULL;
TRAP_IGNORE( repository = CRepository::NewL( KCRUidCmManager ) )
if ( repository )
{
TInt value( 0 );
TInt err = repository->Get( KCurrentCellularDataUsage, value );
if ( err == KErrNone )
{
if ( value == ECmCellularDataUsageDisabled )
{
// Cellular connection is not allowed by user
allowed = EFalse;
}
else
{
MAOConnectionManager::TNetworkType nwType =
iStateContext.ConnectionManager().NetworkType();
if ( ( nwType == MAOConnectionManager::EVPLMN ) &&
( value == ECmCellularDataUsageConfirm ) )
{
// Silent connection is not allowed (will fail)
// in visitor network if user has chosen confirm option.
allowed = EFalse;
}
}
}
}
LOG_2( _L("IsCellularAllowedByUser(): %d"), allowed );
delete repository;
return allowed;
}
void __dummy__(void)
{
OFFSET(UREGS_r15, struct cpu_user_regs, r15);
OFFSET(UREGS_r14, struct cpu_user_regs, r14);
OFFSET(UREGS_r13, struct cpu_user_regs, r13);
OFFSET(UREGS_r12, struct cpu_user_regs, r12);
OFFSET(UREGS_rbp, struct cpu_user_regs, rbp);
OFFSET(UREGS_rbx, struct cpu_user_regs, rbx);
OFFSET(UREGS_r11, struct cpu_user_regs, r11);
OFFSET(UREGS_r10, struct cpu_user_regs, r10);
OFFSET(UREGS_r9, struct cpu_user_regs, r9);
OFFSET(UREGS_r8, struct cpu_user_regs, r8);
OFFSET(UREGS_rax, struct cpu_user_regs, rax);
OFFSET(UREGS_rcx, struct cpu_user_regs, rcx);
OFFSET(UREGS_rdx, struct cpu_user_regs, rdx);
OFFSET(UREGS_rsi, struct cpu_user_regs, rsi);
OFFSET(UREGS_rdi, struct cpu_user_regs, rdi);
OFFSET(UREGS_error_code, struct cpu_user_regs, error_code);
OFFSET(UREGS_entry_vector, struct cpu_user_regs, entry_vector);
OFFSET(UREGS_saved_upcall_mask, struct cpu_user_regs, saved_upcall_mask);
OFFSET(UREGS_rip, struct cpu_user_regs, rip);
OFFSET(UREGS_cs, struct cpu_user_regs, cs);
OFFSET(UREGS_eflags, struct cpu_user_regs, eflags);
OFFSET(UREGS_rsp, struct cpu_user_regs, rsp);
OFFSET(UREGS_ss, struct cpu_user_regs, ss);
OFFSET(UREGS_ds, struct cpu_user_regs, ds);
OFFSET(UREGS_es, struct cpu_user_regs, es);
OFFSET(UREGS_fs, struct cpu_user_regs, fs);
OFFSET(UREGS_gs, struct cpu_user_regs, gs);
OFFSET(UREGS_kernel_sizeof, struct cpu_user_regs, es);
DEFINE(UREGS_user_sizeof, sizeof(struct cpu_user_regs));
BLANK();
OFFSET(irq_caps_offset, struct domain, irq_caps);
OFFSET(next_in_list_offset, struct domain, next_in_list);
OFFSET(VCPU_processor, struct vcpu, processor);
OFFSET(VCPU_domain, struct vcpu, domain);
OFFSET(VCPU_vcpu_info, struct vcpu, vcpu_info);
OFFSET(VCPU_trap_bounce, struct vcpu, arch.trap_bounce);
OFFSET(VCPU_int80_bounce, struct vcpu, arch.int80_bounce);
OFFSET(VCPU_thread_flags, struct vcpu, arch.flags);
OFFSET(VCPU_event_addr, struct vcpu,
arch.guest_context.event_callback_eip);
OFFSET(VCPU_event_sel, struct vcpu,
arch.guest_context.event_callback_cs);
OFFSET(VCPU_failsafe_addr, struct vcpu,
arch.guest_context.failsafe_callback_eip);
OFFSET(VCPU_failsafe_sel, struct vcpu,
arch.guest_context.failsafe_callback_cs);
OFFSET(VCPU_syscall_addr, struct vcpu,
arch.guest_context.syscall_callback_eip);
OFFSET(VCPU_syscall32_addr, struct vcpu, arch.syscall32_callback_eip);
OFFSET(VCPU_syscall32_sel, struct vcpu, arch.syscall32_callback_cs);
OFFSET(VCPU_syscall32_disables_events, struct vcpu,
arch.syscall32_disables_events);
OFFSET(VCPU_sysenter_addr, struct vcpu, arch.sysenter_callback_eip);
OFFSET(VCPU_sysenter_sel, struct vcpu, arch.sysenter_callback_cs);
OFFSET(VCPU_sysenter_disables_events, struct vcpu,
arch.sysenter_disables_events);
OFFSET(VCPU_gp_fault_addr, struct vcpu,
arch.guest_context.trap_ctxt[TRAP_gp_fault].address);
OFFSET(VCPU_gp_fault_sel, struct vcpu,
arch.guest_context.trap_ctxt[TRAP_gp_fault].cs);
OFFSET(VCPU_kernel_sp, struct vcpu, arch.guest_context.kernel_sp);
OFFSET(VCPU_kernel_ss, struct vcpu, arch.guest_context.kernel_ss);
OFFSET(VCPU_guest_context_flags, struct vcpu, arch.guest_context.flags);
OFFSET(VCPU_nmi_pending, struct vcpu, nmi_pending);
OFFSET(VCPU_mce_pending, struct vcpu, mce_pending);
OFFSET(VCPU_nmi_old_mask, struct vcpu, nmi_state.old_mask);
OFFSET(VCPU_mce_old_mask, struct vcpu, mce_state.old_mask);
OFFSET(VCPU_async_exception_mask, struct vcpu, async_exception_mask);
DEFINE(VCPU_TRAP_NMI, VCPU_TRAP_NMI);
DEFINE(VCPU_TRAP_MCE, VCPU_TRAP_MCE);
DEFINE(_VGCF_failsafe_disables_events, _VGCF_failsafe_disables_events);
DEFINE(_VGCF_syscall_disables_events, _VGCF_syscall_disables_events);
BLANK();
OFFSET(VCPU_svm_vmcb_pa, struct vcpu, arch.hvm_svm.vmcb_pa);
OFFSET(VCPU_svm_vmcb, struct vcpu, arch.hvm_svm.vmcb);
OFFSET(VCPU_svm_vmcb_in_sync, struct vcpu, arch.hvm_svm.vmcb_in_sync);
BLANK();
OFFSET(VCPU_vmx_launched, struct vcpu, arch.hvm_vmx.launched);
OFFSET(VCPU_vmx_realmode, struct vcpu, arch.hvm_vmx.vmx_realmode);
OFFSET(VCPU_vmx_emulate, struct vcpu, arch.hvm_vmx.vmx_emulate);
OFFSET(VCPU_vm86_seg_mask, struct vcpu, arch.hvm_vmx.vm86_segment_mask);
OFFSET(VCPU_hvm_guest_cr2, struct vcpu, arch.hvm_vcpu.guest_cr[2]);
BLANK();
OFFSET(DOMAIN_is_32bit_pv, struct domain, arch.is_32bit_pv);
BLANK();
OFFSET(VMCB_rax, struct vmcb_struct, rax);
OFFSET(VMCB_rip, struct vmcb_struct, rip);
OFFSET(VMCB_rsp, struct vmcb_struct, rsp);
OFFSET(VMCB_rflags, struct vmcb_struct, rflags);
BLANK();
OFFSET(VCPUINFO_upcall_pending, struct vcpu_info, evtchn_upcall_pending);
OFFSET(VCPUINFO_upcall_mask, struct vcpu_info, evtchn_upcall_mask);
BLANK();
OFFSET(COMPAT_VCPUINFO_upcall_pending, struct compat_vcpu_info, evtchn_upcall_pending);
OFFSET(COMPAT_VCPUINFO_upcall_mask, struct compat_vcpu_info, evtchn_upcall_mask);
BLANK();
OFFSET(CPUINFO_current_vcpu, struct cpu_info, current_vcpu);
DEFINE(CPUINFO_sizeof, sizeof(struct cpu_info));
BLANK();
OFFSET(TRAPBOUNCE_error_code, struct trap_bounce, error_code);
OFFSET(TRAPBOUNCE_flags, struct trap_bounce, flags);
OFFSET(TRAPBOUNCE_cs, struct trap_bounce, cs);
OFFSET(TRAPBOUNCE_eip, struct trap_bounce, eip);
BLANK();
#if PERF_COUNTERS
DEFINE(PERFC_hypercalls, PERFC_hypercalls);
DEFINE(PERFC_exceptions, PERFC_exceptions);
BLANK();
#endif
DEFINE(IRQSTAT_shift, LOG_2(sizeof(irq_cpustat_t)));
BLANK();
OFFSET(CPUINFO_ext_features, struct cpuinfo_x86, x86_capability[1]);
BLANK();
OFFSET(MB_flags, multiboot_info_t, flags);
OFFSET(MB_cmdline, multiboot_info_t, cmdline);
}
void __dummy__(void)
{
OFFSET(UREGS_r15, struct cpu_user_regs, r15);
OFFSET(UREGS_r14, struct cpu_user_regs, r14);
OFFSET(UREGS_r13, struct cpu_user_regs, r13);
OFFSET(UREGS_r12, struct cpu_user_regs, r12);
OFFSET(UREGS_rbp, struct cpu_user_regs, rbp);
OFFSET(UREGS_rbx, struct cpu_user_regs, rbx);
OFFSET(UREGS_r11, struct cpu_user_regs, r11);
OFFSET(UREGS_r10, struct cpu_user_regs, r10);
OFFSET(UREGS_r9, struct cpu_user_regs, r9);
OFFSET(UREGS_r8, struct cpu_user_regs, r8);
OFFSET(UREGS_rax, struct cpu_user_regs, rax);
OFFSET(UREGS_rcx, struct cpu_user_regs, rcx);
OFFSET(UREGS_rdx, struct cpu_user_regs, rdx);
OFFSET(UREGS_rsi, struct cpu_user_regs, rsi);
OFFSET(UREGS_rdi, struct cpu_user_regs, rdi);
OFFSET(UREGS_error_code, struct cpu_user_regs, error_code);
OFFSET(UREGS_entry_vector, struct cpu_user_regs, entry_vector);
OFFSET(UREGS_saved_upcall_mask, struct cpu_user_regs, saved_upcall_mask);
OFFSET(UREGS_rip, struct cpu_user_regs, rip);
OFFSET(UREGS_cs, struct cpu_user_regs, cs);
OFFSET(UREGS_eflags, struct cpu_user_regs, rflags);
OFFSET(UREGS_rsp, struct cpu_user_regs, rsp);
OFFSET(UREGS_ss, struct cpu_user_regs, ss);
OFFSET(UREGS_ds, struct cpu_user_regs, ds);
OFFSET(UREGS_es, struct cpu_user_regs, es);
OFFSET(UREGS_fs, struct cpu_user_regs, fs);
OFFSET(UREGS_gs, struct cpu_user_regs, gs);
OFFSET(UREGS_kernel_sizeof, struct cpu_user_regs, es);
DEFINE(UREGS_user_sizeof, sizeof(struct cpu_user_regs));
BLANK();
OFFSET(irq_caps_offset, struct domain, irq_caps);
OFFSET(next_in_list_offset, struct domain, next_in_list);
OFFSET(VCPU_processor, struct vcpu, processor);
OFFSET(VCPU_domain, struct vcpu, domain);
OFFSET(VCPU_vcpu_info, struct vcpu, vcpu_info);
OFFSET(VCPU_trap_bounce, struct vcpu, arch.pv_vcpu.trap_bounce);
OFFSET(VCPU_int80_bounce, struct vcpu, arch.pv_vcpu.int80_bounce);
OFFSET(VCPU_thread_flags, struct vcpu, arch.flags);
OFFSET(VCPU_event_addr, struct vcpu, arch.pv_vcpu.event_callback_eip);
OFFSET(VCPU_event_sel, struct vcpu, arch.pv_vcpu.event_callback_cs);
OFFSET(VCPU_failsafe_addr, struct vcpu,
arch.pv_vcpu.failsafe_callback_eip);
OFFSET(VCPU_failsafe_sel, struct vcpu,
arch.pv_vcpu.failsafe_callback_cs);
OFFSET(VCPU_syscall_addr, struct vcpu,
arch.pv_vcpu.syscall_callback_eip);
OFFSET(VCPU_syscall32_addr, struct vcpu,
arch.pv_vcpu.syscall32_callback_eip);
OFFSET(VCPU_syscall32_sel, struct vcpu,
arch.pv_vcpu.syscall32_callback_cs);
OFFSET(VCPU_syscall32_disables_events, struct vcpu,
arch.pv_vcpu.syscall32_disables_events);
OFFSET(VCPU_sysenter_addr, struct vcpu,
arch.pv_vcpu.sysenter_callback_eip);
OFFSET(VCPU_sysenter_sel, struct vcpu,
arch.pv_vcpu.sysenter_callback_cs);
OFFSET(VCPU_sysenter_disables_events, struct vcpu,
arch.pv_vcpu.sysenter_disables_events);
OFFSET(VCPU_trap_ctxt, struct vcpu, arch.pv_vcpu.trap_ctxt);
OFFSET(VCPU_kernel_sp, struct vcpu, arch.pv_vcpu.kernel_sp);
OFFSET(VCPU_kernel_ss, struct vcpu, arch.pv_vcpu.kernel_ss);
OFFSET(VCPU_iopl, struct vcpu, arch.pv_vcpu.iopl);
OFFSET(VCPU_guest_context_flags, struct vcpu, arch.vgc_flags);
OFFSET(VCPU_nmi_pending, struct vcpu, nmi_pending);
OFFSET(VCPU_mce_pending, struct vcpu, mce_pending);
OFFSET(VCPU_nmi_old_mask, struct vcpu, nmi_state.old_mask);
OFFSET(VCPU_mce_old_mask, struct vcpu, mce_state.old_mask);
OFFSET(VCPU_async_exception_mask, struct vcpu, async_exception_mask);
DEFINE(VCPU_TRAP_NMI, VCPU_TRAP_NMI);
DEFINE(VCPU_TRAP_MCE, VCPU_TRAP_MCE);
DEFINE(_VGCF_failsafe_disables_events, _VGCF_failsafe_disables_events);
DEFINE(_VGCF_syscall_disables_events, _VGCF_syscall_disables_events);
BLANK();
OFFSET(VCPU_svm_vmcb_pa, struct vcpu, arch.hvm_svm.vmcb_pa);
OFFSET(VCPU_svm_vmcb, struct vcpu, arch.hvm_svm.vmcb);
OFFSET(VCPU_svm_vmcb_in_sync, struct vcpu, arch.hvm_svm.vmcb_in_sync);
BLANK();
OFFSET(VCPU_vmx_launched, struct vcpu, arch.hvm_vmx.launched);
OFFSET(VCPU_vmx_realmode, struct vcpu, arch.hvm_vmx.vmx_realmode);
OFFSET(VCPU_vmx_emulate, struct vcpu, arch.hvm_vmx.vmx_emulate);
OFFSET(VCPU_vm86_seg_mask, struct vcpu, arch.hvm_vmx.vm86_segment_mask);
OFFSET(VCPU_hvm_guest_cr2, struct vcpu, arch.hvm_vcpu.guest_cr[2]);
BLANK();
OFFSET(VCPU_nhvm_guestmode, struct vcpu, arch.hvm_vcpu.nvcpu.nv_guestmode);
OFFSET(VCPU_nhvm_p2m, struct vcpu, arch.hvm_vcpu.nvcpu.nv_p2m);
OFFSET(VCPU_nsvm_hap_enabled, struct vcpu, arch.hvm_vcpu.nvcpu.u.nsvm.ns_hap_enabled);
BLANK();
OFFSET(DOMAIN_is_32bit_pv, struct domain, arch.is_32bit_pv);
BLANK();
OFFSET(VMCB_rax, struct vmcb_struct, rax);
OFFSET(VMCB_rip, struct vmcb_struct, rip);
OFFSET(VMCB_rsp, struct vmcb_struct, rsp);
OFFSET(VMCB_rflags, struct vmcb_struct, rflags);
BLANK();
OFFSET(VCPUINFO_upcall_pending, struct vcpu_info, evtchn_upcall_pending);
OFFSET(VCPUINFO_upcall_mask, struct vcpu_info, evtchn_upcall_mask);
BLANK();
OFFSET(COMPAT_VCPUINFO_upcall_pending, struct compat_vcpu_info, evtchn_upcall_pending);
OFFSET(COMPAT_VCPUINFO_upcall_mask, struct compat_vcpu_info, evtchn_upcall_mask);
BLANK();
OFFSET(CPUINFO_guest_cpu_user_regs, struct cpu_info, guest_cpu_user_regs);
OFFSET(CPUINFO_processor_id, struct cpu_info, processor_id);
OFFSET(CPUINFO_current_vcpu, struct cpu_info, current_vcpu);
OFFSET(CPUINFO_cr4, struct cpu_info, cr4);
DEFINE(CPUINFO_sizeof, sizeof(struct cpu_info));
BLANK();
OFFSET(TRAPINFO_eip, struct trap_info, address);
OFFSET(TRAPINFO_cs, struct trap_info, cs);
OFFSET(TRAPINFO_flags, struct trap_info, flags);
DEFINE(TRAPINFO_sizeof, sizeof(struct trap_info));
BLANK();
OFFSET(TRAPBOUNCE_error_code, struct trap_bounce, error_code);
OFFSET(TRAPBOUNCE_flags, struct trap_bounce, flags);
OFFSET(TRAPBOUNCE_cs, struct trap_bounce, cs);
OFFSET(TRAPBOUNCE_eip, struct trap_bounce, eip);
BLANK();
#ifdef CONFIG_PERF_COUNTERS
DEFINE(ASM_PERFC_exceptions, PERFC_exceptions);
BLANK();
#endif
DEFINE(IRQSTAT_shift, LOG_2(sizeof(irq_cpustat_t)));
OFFSET(IRQSTAT_softirq_pending, irq_cpustat_t, __softirq_pending);
BLANK();
OFFSET(CPUINFO_features, struct cpuinfo_x86, x86_capability);
BLANK();
OFFSET(MB_flags, multiboot_info_t, flags);
OFFSET(MB_cmdline, multiboot_info_t, cmdline);
OFFSET(MB_mem_lower, multiboot_info_t, mem_lower);
BLANK();
DEFINE(MB2_fixed_sizeof, sizeof(multiboot2_fixed_t));
OFFSET(MB2_fixed_total_size, multiboot2_fixed_t, total_size);
OFFSET(MB2_tag_type, multiboot2_tag_t, type);
OFFSET(MB2_tag_size, multiboot2_tag_t, size);
OFFSET(MB2_load_base_addr, multiboot2_tag_load_base_addr_t, load_base_addr);
OFFSET(MB2_mem_lower, multiboot2_tag_basic_meminfo_t, mem_lower);
OFFSET(MB2_efi64_st, multiboot2_tag_efi64_t, pointer);
OFFSET(MB2_efi64_ih, multiboot2_tag_efi64_ih_t, pointer);
BLANK();
DEFINE(l2_identmap_sizeof, sizeof(l2_identmap));
BLANK();
OFFSET(DOMAIN_vm_assist, struct domain, vm_assist);
}
//-----------------------------------------------------------------------------
// CSilenceAction::RunError
//-----------------------------------------------------------------------------
//
TInt CSilenceAction::RunError( TInt aError )
{
LOG_2( _L("CSilenceAction::RunError aError: %d"), aError );
return aError;
}
