/**
* @param outPattern only set if success is returned; points to referenced open file, so it does
* not need to be free'd/deleted.
*/
FhgfsOpsErr LookupIntentMsgEx::open(EntryInfo* entryInfo, std::string* outFileHandleID,
StripePattern** outPattern, PathInfo* outPathInfo)
{
App* app = Program::getApp();
SessionStore* sessions = app->getSessions();
FileInode* inode;
bool useQuota = isMsgHeaderFeatureFlagSet(LOOKUPINTENTMSG_FLAG_USE_QUOTA);
FhgfsOpsErr openRes = MsgHelperOpen::openFile(
entryInfo, getAccessFlags(), useQuota, getMsgHeaderUserID(), &inode);
if(openRes != FhgfsOpsErr_SUCCESS)
return openRes; // error occurred
// open successful => insert session
SessionFile* sessionFile = new SessionFile(inode, getAccessFlags(), entryInfo);
Session* session = sessions->referenceSession(getSessionID(), true);
*outPattern = inode->getStripePattern();
inode->getPathInfo(outPathInfo);
unsigned ownerFD = session->getFiles()->addSession(sessionFile);
sessions->releaseSession(session);
*outFileHandleID = SessionTk::generateFileHandleID(ownerFD, entryInfo->getEntryID() );
return openRes;
}
virtual ISecResource* clone()
{
CSecurityResource* _res = new CSecurityResource(m_name.get());
if(!_res)
return NULL;
_res->setResourceType(m_resourcetype);
_res->setDescription(m_description.str());
_res->setValue(m_value.str());
_res->setRequiredAccessFlags(getRequiredAccessFlags());
_res->setAccessFlags(getAccessFlags());
if(!m_parameters)
return _res;
Owned<IPropertyIterator> Itr = m_parameters->getIterator();
Itr->first();
while(Itr->isValid())
{
_res->addParameter(Itr->getPropKey(),m_parameters->queryProp(Itr->getPropKey()));
Itr->next();
}
return _res;
}
void VulkanImage::getBarriers(const VkImageSubresourceRange& range, Vector<VkImageMemoryBarrier>& barriers)
{
UINT32 numSubresources = range.levelCount * range.layerCount;
// Nothing to do
if (numSubresources == 0)
return;
UINT32 mip = range.baseMipLevel;
UINT32 face = range.baseArrayLayer;
UINT32 lastMip = range.baseMipLevel + range.levelCount - 1;
UINT32 lastFace = range.baseArrayLayer + range.layerCount - 1;
VkImageMemoryBarrier defaultBarrier;
defaultBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
defaultBarrier.pNext = nullptr;
defaultBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
defaultBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
defaultBarrier.image = getHandle();
defaultBarrier.subresourceRange.aspectMask = range.aspectMask;
defaultBarrier.subresourceRange.layerCount = 1;
defaultBarrier.subresourceRange.levelCount = 1;
defaultBarrier.subresourceRange.baseArrayLayer = 0;
defaultBarrier.subresourceRange.baseMipLevel = 0;
auto addNewBarrier = [&](VulkanImageSubresource* subresource, UINT32 face, UINT32 mip)
{
barriers.push_back(defaultBarrier);
VkImageMemoryBarrier* barrier = &barriers.back();
barrier->subresourceRange.baseArrayLayer = face;
barrier->subresourceRange.baseMipLevel = mip;
barrier->srcAccessMask = getAccessFlags(subresource->getLayout());
barrier->oldLayout = subresource->getLayout();
return barrier;
};
bs_frame_mark();
{
FrameVector<bool> processed(numSubresources, false);
// Add first subresource
VulkanImageSubresource* subresource = getSubresource(face, mip);
addNewBarrier(subresource, face, mip);
numSubresources--;
processed[0] = true;
while (numSubresources > 0)
{
// Try to expand the barrier as much as possible
VkImageMemoryBarrier* barrier = &barriers.back();
while (true)
{
// Expand by one in the X direction
bool expandedFace = true;
if (face < lastFace)
{
for (UINT32 i = 0; i < barrier->subresourceRange.levelCount; i++)
{
UINT32 curMip = barrier->subresourceRange.baseMipLevel + i;
VulkanImageSubresource* subresource = getSubresource(face + 1, curMip);
if (barrier->oldLayout != subresource->getLayout())
{
expandedFace = false;
break;
}
}
if (expandedFace)
{
barrier->subresourceRange.layerCount++;
numSubresources -= barrier->subresourceRange.levelCount;
face++;
for (UINT32 i = 0; i < barrier->subresourceRange.levelCount; i++)
{
UINT32 curMip = (barrier->subresourceRange.baseMipLevel + i) - range.baseMipLevel;
UINT32 idx = curMip * range.layerCount + (face - range.baseArrayLayer);
processed[idx] = true;
}
}
}
else
expandedFace = false;
// Expand by one in the Y direction
bool expandedMip = true;
if (mip < lastMip)
{
for (UINT32 i = 0; i < barrier->subresourceRange.layerCount; i++)
{
UINT32 curFace = barrier->subresourceRange.baseArrayLayer + i;
VulkanImageSubresource* subresource = getSubresource(curFace, mip + 1);
if (barrier->oldLayout != subresource->getLayout())
{
expandedMip = false;
break;
}
}
if (expandedMip)
{
barrier->subresourceRange.levelCount++;
numSubresources -= barrier->subresourceRange.layerCount;
mip++;
for (UINT32 i = 0; i < barrier->subresourceRange.layerCount; i++)
{
UINT32 curFace = (barrier->subresourceRange.baseArrayLayer + i) - range.baseArrayLayer;
UINT32 idx = (mip - range.baseMipLevel) * range.layerCount + curFace;
processed[idx] = true;
}
}
}
else
expandedMip = false;
// If we can't grow no more, we're done with this square
if (!expandedMip && !expandedFace)
break;
}
// Look for a new starting point (sub-resource we haven't processed yet)
for (UINT32 i = 0; i < range.levelCount; i++)
{
bool found = false;
for (UINT32 j = 0; j < range.layerCount; j++)
{
UINT32 idx = i * range.layerCount + j;
if (!processed[idx])
{
mip = range.baseMipLevel + i;
face = range.baseArrayLayer + j;
found = true;
processed[idx] = true;
break;
}
}
if (found)
{
VulkanImageSubresource* subresource = getSubresource(face, mip);
addNewBarrier(subresource, face, mip);
numSubresources--;
break;
}
}
}
}
bs_frame_clear();
}
