void emulator_runmode::decay_skiplag()
{
revalidate();
if(mode == SKIPLAG_PENDING) {
mode = SKIPLAG;
}
}
void emulator_runmode::decay_break()
{
revalidate();
if(mode == PAUSE_BREAK) {
mode = PAUSE;
}
}
/* Load data to corresponding widgets from cache,
* this task SHOULD be performed in GUI thread only: */
void UIMachineSettingsParallelPage::getFromCache()
{
/* Setup tab order: */
Assert(firstWidget());
setTabOrder(firstWidget(), mTabWidget->focusProxy());
QWidget *pLastFocusWidget = mTabWidget->focusProxy();
/* For each parallel port: */
for (int iPort = 0; iPort < mTabWidget->count(); ++iPort)
{
/* Get port page: */
UIMachineSettingsParallel *pPage = qobject_cast<UIMachineSettingsParallel*>(mTabWidget->widget(iPort));
/* Load port data to page: */
pPage->fetchPortData(m_cache.child(iPort));
/* Setup tab order: */
pLastFocusWidget = pPage->setOrderAfter(pLastFocusWidget);
}
/* Applying language settings: */
retranslateUi();
/* Polish page finally: */
polishPage();
/* Revalidate: */
revalidate();
}
void UIMachineSettingsDisplay::setGuestOSType(CGuestOSType guestOSType)
{
/* Check if guest os type changed: */
if (m_guestOSType == guestOSType)
return;
/* Remember new guest os type: */
m_guestOSType = guestOSType;
#ifdef VBOX_WITH_VIDEOHWACCEL
/* Check if 2D video acceleration supported by the guest OS type: */
QString strguestOSTypeFamily = m_guestOSType.GetFamilyId();
m_f2DVideoAccelerationSupported = strguestOSTypeFamily == "Windows";
#endif /* VBOX_WITH_VIDEOHWACCEL */
#ifdef VBOX_WITH_CRHGSMI
/* Check if WDDM mode supported by the guest OS type: */
QString strguestOSTypeId = m_guestOSType.GetId();
m_fWddmModeSupported = VBoxGlobal::isWddmCompatibleOsType(strguestOSTypeId);
#endif /* VBOX_WITH_CRHGSMI */
/* Recheck video RAM requirement: */
checkVRAMRequirements();
/* Revalidate: */
revalidate();
}
static int resolve(ITF *itf,uint32_t ip,ENTRY **entry,int want_vc)
{
*entry = lookup_ip(itf,ip);
if ((!*entry || (*entry)->state != as_valid) && !itf->arp_srv)
return -1; /* bad luck - no ARP server when we need one */
if (*entry) {
if (want_vc) (*entry)->flags &= ~ATF_NOVC;
switch ((*entry)->state) {
case as_resolv:
return 1; /* somebody else is already taking care of that */
case as_valid:
if (!(*entry)->vccs && !((*entry)->flags & ATF_NOVC))
connect_me(*entry);
return 0;
case as_invalid:
if ((*entry)->svc && (*entry)->itf && (*entry)->itf->arp_srv &&
!((*entry)->flags & ATF_ARPSRV)) break;
return -1;
default:
diag(COMPONENT,DIAG_FATAL,"bad state %d",(*entry)->state);
}
}
else {
*entry = alloc_entry(1);
(*entry)->flags = ATF_PUBL | (want_vc ? 0 : ATF_NOVC);
(*entry)->ip = ip;
(*entry)->itf = itf;
Q_INSERT_HEAD(itf->table,*entry);
(*entry)->qos = itf->qos;
}
revalidate(*entry);
return 1;
}
/* Load data to corresponding widgets from cache,
* this task SHOULD be performed in GUI thread only: */
void UIMachineSettingsNetworkPage::getFromCache()
{
/* Setup tab order: */
Assert(firstWidget());
setTabOrder(firstWidget(), m_pTwAdapters->focusProxy());
QWidget *pLastFocusWidget = m_pTwAdapters->focusProxy();
/* For each network adapter: */
for (int iSlot = 0; iSlot < m_pTwAdapters->count(); ++iSlot)
{
/* Get adapter page: */
UIMachineSettingsNetwork *pTab = qobject_cast<UIMachineSettingsNetwork*>(m_pTwAdapters->widget(iSlot));
/* Load adapter data to page: */
pTab->fetchAdapterCache(m_cache.child(iSlot));
/* Setup tab order: */
pLastFocusWidget = pTab->setOrderAfter(pLastFocusWidget);
}
/* Applying language settings: */
retranslateUi();
/* Polish page finally: */
polishPage();
/* Revalidate: */
revalidate();
}
void UIMachineSettingsDisplay::sltHandleVideoMemorySizeEditorChange()
{
/* Apply proposed memory-size: */
m_pSliderVideoMemorySize->blockSignals(true);
m_pSliderVideoMemorySize->setValue(m_pEditorVideoMemorySize->value());
m_pSliderVideoMemorySize->blockSignals(false);
/* Revalidate: */
revalidate();
}
void UIMachineSettingsSystem::sltHandleCPUExecCapEditorChange()
{
/* Apply new memory-size value: */
m_pSliderCPUExecCap->blockSignals(true);
m_pSliderCPUExecCap->setValue(m_pEditorCPUExecCap->value());
m_pSliderCPUExecCap->blockSignals(false);
/* Revalidate: */
revalidate();
}
void UICloudProfileDetailsWidget::sltNameChanged(const QString &strName)
{
/* Push changes back: */
m_newData.m_strName = strName;
/* Revalidate: */
revalidate(m_pEditorName);
/* Update button states: */
updateButtonStates();
}
void UIMachineSettingsGeneral::setHWVirtExEnabled(bool fEnabled)
{
/* Make sure hardware virtualization extension has changed: */
if (m_fHWVirtExEnabled == fEnabled)
return;
/* Update hardware virtualization extension value: */
m_fHWVirtExEnabled = fEnabled;
/* Revalidate: */
revalidate();
}
void UIMachineSettingsSystem::setOHCIEnabled(bool fEnabled)
{
/* Make sure OHCI status has changed: */
if (m_fOHCIEnabled == fEnabled)
return;
/* Update OHCI status value: */
m_fOHCIEnabled = fEnabled;
/* Revalidate: */
revalidate();
}
static void timeout(ENTRY *entry)
{
VCC *vcc,*next;
entry->timer = NULL;
switch (entry->state) {
case as_resolv:
send_notifications(entry,0);
if ((entry->flags & ATF_ARPSRV) && !entry->vccs) {
if (entry->itf) want_arp_srv(entry->itf);
break;
}
if (!entry->vccs && !(entry->flags & (ATF_PERM | ATF_ARPSRV)))
discard_entry(entry);
else entry->state = as_invalid;
break;
case as_valid:
if (!entry->vccs && !(entry->flags & (ATF_PERM | ATF_ARPSRV)) &&
entry->itf->arp_srv) {
discard_entry(entry);
break;
}
for (vcc = entry->vccs; vcc; vcc = next) {
next = vcc->next;
if (!vcc->connecting)
if (set_ip(vcc->fd,0) < 0) {
diag(COMPONENT,DIAG_ERROR,"set_ip(0): %s",
strerror(errno));
disconnect_vcc(vcc);
}
}
if (entry->svc && entry->itf->arp_srv &&
!(entry->flags & ATF_ARPSRV)) revalidate(entry);
else {
inarp_request(entry);
START_TIMER(entry,REPLY);
entry->state = as_invalid;
}
break;
case as_invalid:
if (!entry->svc) {
inarp_request(entry);
START_TIMER(entry,REPLY);
}
else if ((!entry->itf || !entry->itf->arp_srv) &&
!(entry->flags & ATF_PERM)) discard_entry(entry);
break;
default:
diag(COMPONENT,DIAG_FATAL,"timed out in state %s",
entry_state_name[entry->state]);
}
}
void UIMachineSettingsDisplay::sltHandleVideoScreenCountEditorChange()
{
/* Apply proposed screen-count: */
m_pSliderVideoScreenCount->blockSignals(true);
m_pSliderVideoScreenCount->setValue(m_pEditorVideoScreenCount->value());
m_pSliderVideoScreenCount->blockSignals(false);
/* Update Video RAM requirements: */
checkVRAMRequirements();
/* Update Video Capture tab screen count: */
updateVideoCaptureScreenCount();
/* Revalidate: */
revalidate();
}
/* Load data to corresponding widgets from cache,
* this task SHOULD be performed in GUI thread only: */
void UIMachineSettingsSystem::getFromCache()
{
/* Get system data from cache: */
const UIDataSettingsMachineSystem &systemData = m_cache.base();
/* Repopulate 'pointing HID type' combo.
* We are doing that *now* because it has dynamical content
* which depends on recashed value: */
repopulateComboPointingHIDType();
/* Load motherboard data to page: */
m_pSliderMemorySize->setValue(systemData.m_iMemorySize);
/* Remove any old data in the boot view: */
QAbstractItemView *iv = qobject_cast <QAbstractItemView*> (mTwBootOrder);
iv->model()->removeRows(0, iv->model()->rowCount());
/* Apply internal variables data to QWidget(s): */
for (int i = 0; i < systemData.m_bootItems.size(); ++i)
{
UIBootItemData data = systemData.m_bootItems[i];
QListWidgetItem *pItem = new UIBootTableItem(data.m_type);
pItem->setCheckState(data.m_fEnabled ? Qt::Checked : Qt::Unchecked);
mTwBootOrder->addItem(pItem);
}
/* Load other motherboard data to page: */
int iChipsetTypePosition = m_pComboChipsetType->findData(systemData.m_chipsetType);
m_pComboChipsetType->setCurrentIndex(iChipsetTypePosition == -1 ? 0 : iChipsetTypePosition);
int iHIDTypePosition = m_pComboPointingHIDType->findData(systemData.m_pointingHIDType);
m_pComboPointingHIDType->setCurrentIndex(iHIDTypePosition == -1 ? 0 : iHIDTypePosition);
m_pCheckBoxApic->setChecked(systemData.m_fEnabledIoApic);
m_pCheckBoxEFI->setChecked(systemData.m_fEnabledEFI);
m_pCheckBoxUseUTC->setChecked(systemData.m_fEnabledUTC);
/* Load CPU data to page: */
m_pSliderCPUCount->setValue(systemData.m_cCPUCount);
m_pSliderCPUExecCap->setValue(systemData.m_iCPUExecCap);
m_pCheckBoxPAE->setChecked(systemData.m_fEnabledPAE);
/* Load acceleration data to page: */
m_pCheckBoxVirtualization->setChecked(systemData.m_fEnabledHwVirtEx);
m_pCheckBoxNestedPaging->setChecked(systemData.m_fEnabledNestedPaging);
/* Polish page finally: */
polishPage();
/* Revalidate: */
revalidate();
}
void UIGlobalSettingsNetwork::getFromCache()
{
/* Fetch NAT networks from cache: */
foreach (const UIDataNetworkNAT &network, m_cache.m_networksNAT)
createTreeItemNetworkNAT(network);
m_pTreeNetworkNAT->setCurrentItem(m_pTreeNetworkNAT->topLevelItem(0));
sltHandleCurrentItemChangeNetworkNAT();
/* Fetch Host networks from cache: */
foreach (const UIDataNetworkHost &network, m_cache.m_networksHost)
createTreeItemNetworkHost(network);
m_pTreeNetworkHost->setCurrentItem(m_pTreeNetworkHost->topLevelItem(0));
sltHandleCurrentItemChangeNetworkHost();
/* Revalidate: */
revalidate();
}
/* Load data to corresponding widgets from cache,
* this task SHOULD be performed in GUI thread only: */
void UIMachineSettingsDisplay::getFromCache()
{
/* Get display data from cache: */
const UIDataSettingsMachineDisplay &displayData = m_cache.base();
/* Load Screen data to page: */
m_pEditorVideoScreenCount->setValue(displayData.m_cGuestScreenCount);
m_pEditorGuestScreenScale->setValue((int)(displayData.m_dScaleFactor * 100));
#ifdef Q_WS_MAC
m_pCheckBoxUnscaledHiDPIOutput->setChecked(displayData.m_fUseUnscaledHiDPIOutput);
#endif /* Q_WS_MAC */
m_pCheckbox3D->setChecked(displayData.m_f3dAccelerationEnabled);
#ifdef VBOX_WITH_VIDEOHWACCEL
m_pCheckbox2DVideo->setChecked(displayData.m_f2dAccelerationEnabled);
#endif /* VBOX_WITH_VIDEOHWACCEL */
/* Should be the last one from this tab: */
m_pEditorVideoMemorySize->setValue(displayData.m_iCurrentVRAM);
/* If Remote Display server is supported: */
if (displayData.m_fRemoteDisplayServerSupported)
{
/* Load Remote Display data to page: */
m_pCheckboxRemoteDisplay->setChecked(displayData.m_fRemoteDisplayServerEnabled);
m_pEditorRemoteDisplayPort->setText(displayData.m_strRemoteDisplayPort);
m_pComboRemoteDisplayAuthMethod->setCurrentIndex(m_pComboRemoteDisplayAuthMethod->findText(gpConverter->toString(displayData.m_remoteDisplayAuthType)));
m_pEditorRemoteDisplayTimeout->setText(QString::number(displayData.m_uRemoteDisplayTimeout));
m_pCheckboxMultipleConn->setChecked(displayData.m_fRemoteDisplayMultiConnAllowed);
}
/* Load Video Capture data to page: */
m_pCheckboxVideoCapture->setChecked(displayData.m_fVideoCaptureEnabled);
m_pEditorVideoCapturePath->setHomeDir(displayData.m_strVideoCaptureFolder);
m_pEditorVideoCapturePath->setPath(displayData.m_strVideoCaptureFilePath);
m_pEditorVideoCaptureWidth->setValue(displayData.m_iVideoCaptureFrameWidth);
m_pEditorVideoCaptureHeight->setValue(displayData.m_iVideoCaptureFrameHeight);
m_pEditorVideoCaptureFrameRate->setValue(displayData.m_iVideoCaptureFrameRate);
m_pEditorVideoCaptureBitRate->setValue(displayData.m_iVideoCaptureBitRate);
m_pScrollerVideoCaptureScreens->setValue(displayData.m_screens);
/* Polish page finally: */
polishPage();
/* Revalidate: */
revalidate();
}
void UIMachineSettingsGeneral::getFromCache()
{
/* Get general data from cache: */
const UIDataSettingsMachineGeneral &generalData = m_cache.base();
/* 'Basic' tab data: */
AssertPtrReturnVoid(m_pNameAndSystemEditor);
m_pNameAndSystemEditor->setName(generalData.m_strName);
m_pNameAndSystemEditor->setType(vboxGlobal().vmGuestOSType(generalData.m_strGuestOsTypeId));
/* 'Advanced' tab data: */
AssertPtrReturnVoid(mPsSnapshot);
AssertPtrReturnVoid(mCbClipboard);
AssertPtrReturnVoid(mCbDragAndDrop);
mPsSnapshot->setPath(generalData.m_strSnapshotsFolder);
mPsSnapshot->setHomeDir(generalData.m_strSnapshotsHomeDir);
mCbClipboard->setCurrentIndex(generalData.m_clipboardMode);
mCbDragAndDrop->setCurrentIndex(generalData.m_dndMode);
/* 'Description' tab data: */
AssertPtrReturnVoid(mTeDescription);
mTeDescription->setPlainText(generalData.m_strDescription);
/* 'Encryption' tab data: */
AssertPtrReturnVoid(m_pCheckBoxEncryption);
AssertPtrReturnVoid(m_pComboCipher);
m_pCheckBoxEncryption->setChecked(generalData.m_fEncryptionEnabled);
m_pComboCipher->setCurrentIndex(generalData.m_iEncryptionCipherIndex);
m_fEncryptionCipherChanged = generalData.m_fEncryptionCipherChanged;
m_fEncryptionPasswordChanged = generalData.m_fEncryptionPasswordChanged;
/* Polish page finally: */
polishPage();
/* Revalidate: */
revalidate();
}
void UICloudProfileDetailsWidget::sltTableChanged(QTableWidgetItem *pItem)
{
/* Make sure item is valid: */
AssertPtrReturnVoid(pItem);
const int iRow = pItem->row();
AssertReturnVoid(iRow >= 0);
/* Skip if one of items isn't yet created.
* This can happen when 1st is already while 2nd isn't yet. */
QTableWidgetItem *pItemK = m_pTableWidget->item(iRow, 0);
QTableWidgetItem *pItemV = m_pTableWidget->item(iRow, 1);
if (!pItemK || !pItemV)
return;
/* Push changes back: */
const QString strKey = pItemK->text();
const QString strValue = pItemV->text();
m_newData.m_data[strKey] = qMakePair(strValue, m_newData.m_data.value(strKey).second);
/* Revalidate: */
revalidate(m_pTableWidget);
/* Update button states: */
updateButtonStates();
}
uint64_t emulator_runmode::get()
{
revalidate();
return mode;
}
bool TrWindow::qt_invoke( int _id, QUObject* _o )
{
switch ( _id - staticMetaObject()->slotOffset() ) {
case 0:
doneAndNext();
break;
case 1:
prev();
break;
case 2:
next();
break;
case 3:
recentFileActivated((int)static_QUType_int.get(_o+1));
break;
case 4:
setupRecentFilesMenu();
break;
case 5:
open();
break;
case 6:
save();
break;
case 7:
saveAs();
break;
case 8:
release();
break;
case 9:
print();
break;
case 10:
find();
break;
case 11:
findAgain();
break;
case 12:
replace();
break;
case 13:
newPhraseBook();
break;
case 14:
openPhraseBook();
break;
case 15:
closePhraseBook((int)static_QUType_int.get(_o+1));
break;
case 16:
editPhraseBook((int)static_QUType_int.get(_o+1));
break;
case 17:
printPhraseBook((int)static_QUType_int.get(_o+1));
break;
case 18:
manual();
break;
case 19:
revertSorting();
break;
case 20:
about();
break;
case 21:
aboutQt();
break;
case 22:
setupPhrase();
break;
case 23:
static_QUType_bool.set(_o,maybeSave());
break;
case 24:
updateCaption();
break;
case 25:
showNewScope((QListViewItem*)static_QUType_ptr.get(_o+1));
break;
case 26:
showNewCurrent((QListViewItem*)static_QUType_ptr.get(_o+1));
break;
case 27:
updateTranslation((const QString&)static_QUType_QString.get(_o+1));
break;
case 28:
updateFinished((bool)static_QUType_bool.get(_o+1));
break;
case 29:
toggleFinished((QListViewItem*)static_QUType_ptr.get(_o+1),(const QPoint&)*((const QPoint*)static_QUType_ptr.get(_o+2)),(int)static_QUType_int.get(_o+3));
break;
case 30:
prevUnfinished();
break;
case 31:
nextUnfinished();
break;
case 32:
findNext((const QString&)static_QUType_QString.get(_o+1),(int)static_QUType_int.get(_o+2),(bool)static_QUType_bool.get(_o+3));
break;
case 33:
revalidate();
break;
case 34:
toggleGuessing();
break;
case 35:
focusSourceList();
break;
case 36:
focusPhraseList();
break;
case 37:
updateClosePhraseBook();
break;
case 38:
toggleStatistics();
break;
case 39:
updateStatistics();
break;
default:
return QMainWindow::qt_invoke( _id, _o );
}
return TRUE;
}
bool LookupIntentMsgEx::processIncoming(struct sockaddr_in* fromAddr, Socket* sock,
char* respBuf, size_t bufLen, HighResolutionStats* stats)
{
#ifdef BEEGFS_DEBUG
const char* msgInContext = "LookupIntentMsg incoming";
std::string peer = fromAddr ? Socket::ipaddrToStr(&fromAddr->sin_addr) : sock->getPeername();
LOG_DEBUG(msgInContext, 4, std::string("Received a LookupIntentMsg from: ") + peer);
#endif
App* app = Program::getApp();
std::string parentEntryID = getParentInfo()->getEntryID();
FhgfsOpsErr lookupRes = FhgfsOpsErr_INTERNAL;
FhgfsOpsErr createRes = FhgfsOpsErr_INTERNAL;
std::string entryName = getEntryName();
const char* logContext = "LookupIntentMsg";
LOG_DEBUG(logContext, 5, "parentID: '" + parentEntryID + "' " +
"entryName: '" + entryName + "'");
// (note: following objects must be at the top-level stack frame for response serialization)
std::string fileHandleID;
Raid0Pattern dummyPattern(1, UInt16Vector() );
EntryInfo diskEntryInfo;
int createFlag = getIntentFlags() & LOOKUPINTENTMSG_FLAG_CREATE;
FileInodeStoreData inodeData;
bool inodeDataOutdated = false; // true if the file/inode is currently open (referenced)
LookupIntentRespMsg respMsg(FhgfsOpsErr_INTERNAL);
PathInfo pathInfo; /* Added to NetMessage as ref-pointer, so object needs to exist until
* the NetMessage got serialized! */
// sanity checks
if (unlikely (parentEntryID.empty() || entryName.empty() ) )
{
LogContext(logContext).log(3, "Sanity check failed: parentEntryID: '"
+ parentEntryID + "'" + "entryName: '" + entryName + "'");
// something entirely wrong, fail immediately, error already set above
goto send_response;
}
/* Note: Actually we should first do a lookup. However, a successful create also implies a
failed Lookup, so we can take a shortcut. */
// lookup-create
if (createFlag)
{
LOG_DEBUG(logContext, Log_SPAM, "Lookup: create");
// checks in create() if lookup already found the entry
createRes = create(this->getParentInfo(), entryName, &diskEntryInfo,
&inodeData);
FhgfsOpsErr sendCreateRes;
if (createRes == FhgfsOpsErr_SUCCESS)
{
sendCreateRes = FhgfsOpsErr_SUCCESS;
// Successful Create, which implies Lookup-before-create would have been failed.
respMsg.setLookupResult(FhgfsOpsErr_PATHNOTEXISTS);
respMsg.setEntryInfo(&diskEntryInfo);
}
else
{
if (createRes == FhgfsOpsErr_EXISTS)
{
// NOTE: we need to do a Lookup to get required lookup data
if (getIntentFlags() & LOOKUPINTENTMSG_FLAG_CREATEEXCLUSIVE)
sendCreateRes = FhgfsOpsErr_EXISTS;
else
sendCreateRes = FhgfsOpsErr_SUCCESS;
}
else
sendCreateRes = FhgfsOpsErr_INTERNAL;
}
respMsg.addResponseCreate(sendCreateRes);
// note: don't quit here on error because caller might still have requested stat info
}
// lookup
if ((!createFlag) || (createRes == FhgfsOpsErr_EXISTS) )
{
LOG_DEBUG(logContext, Log_SPAM, "Lookup: lookup");
lookupRes = lookup(parentEntryID, entryName, &diskEntryInfo, &inodeData, inodeDataOutdated);
respMsg.setLookupResult(lookupRes);
if (lookupRes == FhgfsOpsErr_SUCCESS)
respMsg.setEntryInfo(&diskEntryInfo);
if(unlikely( (lookupRes != FhgfsOpsErr_SUCCESS) && createFlag) )
{
// so createFlag is set, so createRes is either Success or Exists, but now lookup fails
// create/unlink race?
// we need to set something here, as sendCreateRes = FhgfsOpsErr_SUCCESS
respMsg.setEntryInfo(&diskEntryInfo);
StatData statData;
statData.setAllFake(); // set arbitrary stat values (receiver won't use the values)
respMsg.addResponseStat(lookupRes, &statData);
goto send_response;
}
}
// lookup-revalidate
if(getIntentFlags() & LOOKUPINTENTMSG_FLAG_REVALIDATE)
{
LOG_DEBUG(logContext, Log_SPAM, "Lookup: revalidate");
FhgfsOpsErr revalidateRes = revalidate(&diskEntryInfo);
respMsg.addResponseRevalidate(revalidateRes);
if(revalidateRes != FhgfsOpsErr_SUCCESS)
goto send_response;
}
/* lookup-stat
note: we do stat before open to avoid the dyn attribs refresh if the file is not opened by
someone else currently. */
if ( (getIntentFlags() & LOOKUPINTENTMSG_FLAG_STAT) &&
(lookupRes == FhgfsOpsErr_SUCCESS || createRes == FhgfsOpsErr_SUCCESS) )
{
LOG_DEBUG(logContext, Log_SPAM, "Lookup: stat");
// check if lookup and create failed (we don't have an entryID to stat then)
if(diskEntryInfo.getEntryID().empty() )
goto send_response;
if ( (diskEntryInfo.getFlags() & ENTRYINFO_FEATURE_INLINED) && !inodeDataOutdated)
{ // stat-data from the dentry
StatData* dentryStatData = inodeData.getInodeStatData();
respMsg.addResponseStat(FhgfsOpsErr_SUCCESS, dentryStatData);
}
else
{ // read stat data separately
StatData statData;
FhgfsOpsErr statRes = stat(&diskEntryInfo, true, statData);
respMsg.addResponseStat(statRes, &statData);
if(statRes != FhgfsOpsErr_SUCCESS)
goto send_response;
}
}
// lookup-open
if(getIntentFlags() & LOOKUPINTENTMSG_FLAG_OPEN)
{
LOG_DEBUG(logContext, Log_SPAM, "Lookup: open");
// don't open if create failed
if ((createRes != FhgfsOpsErr_SUCCESS) && (getIntentFlags() & LOOKUPINTENTMSG_FLAG_CREATE) )
goto send_response;
if (!DirEntryType_ISREGULARFILE(diskEntryInfo.getEntryType() ) )
goto send_response; // not a regular file, we don't open that
// check if lookup and/or create failed (we don't have an entryID to open then)
if(diskEntryInfo.getEntryID().empty() )
goto send_response;
StripePattern* pattern = NULL;
FhgfsOpsErr openRes = open(&diskEntryInfo, &fileHandleID, &pattern, &pathInfo);
if(openRes != FhgfsOpsErr_SUCCESS)
{ // open failed => use dummy pattern for response
respMsg.addResponseOpen(openRes, fileHandleID, &dummyPattern, &pathInfo);
goto send_response;
}
respMsg.addResponseOpen(openRes, fileHandleID, pattern, &pathInfo);
}
send_response:
respMsg.serialize(respBuf, bufLen);
sock->sendto(respBuf, respMsg.getMsgLength(), 0,
(struct sockaddr*)fromAddr, sizeof(struct sockaddr_in) );
app->getNodeOpStats()->updateNodeOp(sock->getPeerIP(), this->getOpCounterType(),
getMsgHeaderUserID() );
return true;
}
void UIMachineSettingsGeneral::setValidator (QIWidgetValidator *aVal)
{
mValidator = aVal;
connect (m_pNameAndSystemEditor, SIGNAL (sigOsTypeChanged()), mValidator, SLOT (revalidate()));
}
bool emulator_runmode::is(uint64_t m)
{
revalidate();
return ((mode & m) != 0);
}