void
DblqhProxy::execSTART_RECREQ(Signal* signal)
{
if (refToMain(signal->getSendersBlockRef()) == DBLQH) {
jam();
execSTART_RECREQ_2(signal);
return;
}
const StartRecReq* req = (const StartRecReq*)signal->getDataPtr();
Ss_START_RECREQ& ss = ssSeize<Ss_START_RECREQ>();
ss.m_req = *req;
// seize records for sub-ops
Uint32 i;
for (i = 0; i < ss.m_req2cnt; i++) {
Ss_START_RECREQ_2::Req tmp;
tmp.proxyBlockNo = ss.m_req2[i].m_blockNo;
Uint32 ssId2 = getSsId(&tmp);
Ss_START_RECREQ_2& ss2 = ssSeize<Ss_START_RECREQ_2>(ssId2);
ss.m_req2[i].m_ssId = ssId2;
// set wait-for bitmask in SsParallel
setMask(ss2);
}
ndbrequire(signal->getLength() == StartRecReq::SignalLength);
sendREQ(signal, ss);
}
/*
* Set index online. Currently at system restart this arrives before
* build and is therefore not correct.
*/
void
Dbtux::execALTER_INDX_IMPL_REQ(Signal* signal)
{
jamEntry();
const AlterIndxImplReq reqCopy = *(const AlterIndxImplReq*)signal->getDataPtr();
const AlterIndxImplReq* const req = &reqCopy;
IndexPtr indexPtr;
c_indexPool.getPtr(indexPtr, req->indexId);
//Uint32 save = indexPtr.p->m_state;
if (! (refToBlock(req->senderRef) == DBDICT) &&
! (isNdbMt() && refToMain(req->senderRef) == DBTUX &&
refToInstance(req->senderRef) == 0))
{
/**
* DICT has a really distorted view of the world...
* ignore it :(
*/
jam();
switch(req->requestType){
case AlterIndxImplReq::AlterIndexOffline:
jam();
/*
* This happens at failed index build, and before dropping an
* Online index. It causes scans to terminate.
*/
indexPtr.p->m_state = Index::Dropping;
break;
case AlterIndxImplReq::AlterIndexBuilding:
jam();
indexPtr.p->m_state = Index::Building;
break;
default:
jam(); // fall-through
case AlterIndxImplReq::AlterIndexOnline:
jam();
indexPtr.p->m_state = Index::Online;
break;
}
}
// success
AlterIndxImplConf* const conf = (AlterIndxImplConf*)signal->getDataPtrSend();
conf->senderRef = reference();
conf->senderData = req->senderData;
if (req->senderRef != 0)
{
/**
* TUP cheats and does execute direct
* setting UserRef to 0
*/
jam();
sendSignal(req->senderRef, GSN_ALTER_INDX_IMPL_CONF,
signal, AlterIndxImplConf::SignalLength, JBB);
}
}
void
DblqhProxy::execSTART_RECCONF(Signal* signal)
{
const StartRecConf* conf = (const StartRecConf*)signal->getDataPtr();
if (refToMain(signal->getSendersBlockRef()) != DBLQH) {
jam();
execSTART_RECCONF_2(signal);
return;
}
Uint32 ssId = conf->senderData;
Ss_START_RECREQ& ss = ssFind<Ss_START_RECREQ>(ssId);
recvCONF(signal, ss);
}
void Win32AsyncFile::openReq(Request* request)
{
m_auto_sync_freq = 0;
m_write_wo_sync = 0;
m_open_flags = request->par.open.flags;
// for open.flags, see signal FSOPENREQ
DWORD dwCreationDisposition;
DWORD dwDesiredAccess = 0;
DWORD dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
/**
* FIXME:
* Previously we had FILE_FLAG_NO_BUFFERING also set here.
* This has similar alignment rules to O_DIRECT on 2.4 kernels.
* which means we should obey the directio req as we can't do it
* everywhere (this seemingly "worked" in 5.0 though), e.g. by default
* LCP isn't aligned IO.
*/
DWORD dwFlagsAndAttributes = FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS;
Uint32 flags = request->par.open.flags;
// Convert file open flags from Solaris to Windows
if ((flags & FsOpenReq::OM_CREATE) && (flags & FsOpenReq::OM_TRUNCATE)){
dwCreationDisposition = CREATE_ALWAYS;
} else if (flags & FsOpenReq::OM_TRUNCATE){
dwCreationDisposition = TRUNCATE_EXISTING;
} else if (flags & (FsOpenReq::OM_CREATE|FsOpenReq::OM_CREATE_IF_NONE)){
dwCreationDisposition = CREATE_NEW;
} else {
dwCreationDisposition = OPEN_EXISTING;
}
switch(flags & 3){
case FsOpenReq::OM_READONLY:
dwDesiredAccess = GENERIC_READ;
break;
case FsOpenReq::OM_WRITEONLY:
dwDesiredAccess = GENERIC_WRITE;
break;
case FsOpenReq::OM_READWRITE:
dwDesiredAccess = GENERIC_READ | GENERIC_WRITE;
break;
default:
request->error = 1000;
break;
return;
}
hFile = CreateFile(theFileName.c_str(), dwDesiredAccess, dwShareMode,
0, dwCreationDisposition, dwFlagsAndAttributes, 0);
if(INVALID_HANDLE_VALUE == hFile) {
request->error = GetLastError();
if(((ERROR_PATH_NOT_FOUND == request->error) || (ERROR_INVALID_NAME == request->error))
&& (flags & (FsOpenReq::OM_CREATE|FsOpenReq::OM_CREATE_IF_NONE))) {
createDirectories();
hFile = CreateFile(theFileName.c_str(), dwDesiredAccess, dwShareMode,
0, dwCreationDisposition, dwFlagsAndAttributes, 0);
if(INVALID_HANDLE_VALUE == hFile)
request->error = GetLastError();
else
request->error = 0;
}
}
else {
request->error = 0;
}
if (flags & FsOpenReq::OM_INIT)
{
LARGE_INTEGER off;
off.QuadPart= 0;
LARGE_INTEGER sz;
sz.QuadPart= request->par.open.file_size;
char buf[4096];
bzero(buf,sizeof(buf));
while(off.QuadPart < sz.QuadPart)
{
BOOL r= SetFilePointerEx(hFile, off, NULL, FILE_BEGIN);
if(r==0)
{
request->error= GetLastError();
return;
}
DWORD dwWritten;
BOOL bWrite= WriteFile(hFile, buf, sizeof(buf), &dwWritten, 0);
if(!bWrite || dwWritten!=sizeof(buf))
{
request->error= GetLastError();
}
off.QuadPart+=sizeof(buf);
}
off.QuadPart= 0;
BOOL r= SetFilePointerEx(hFile, off, NULL, FILE_BEGIN);
if(r==0)
{
request->error= GetLastError();
return;
}
/* Write initial data */
SignalT<25> tmp;
Signal * signal = (Signal*)(&tmp);
bzero(signal, sizeof(tmp));
FsReadWriteReq* req = (FsReadWriteReq*)signal->getDataPtrSend();
Uint32 index = 0;
Uint32 block = refToMain(request->theUserReference);
Uint32 instance = refToInstance(request->theUserReference);
off.QuadPart= 0;
sz.QuadPart= request->par.open.file_size;
while(off.QuadPart < sz.QuadPart)
{
req->filePointer = 0; // DATA 0
req->userPointer = request->theUserPointer; // DATA 2
req->numberOfPages = 1; // DATA 5
req->varIndex = index++;
req->data.pageData[0] = m_page_ptr.i;
m_fs.EXECUTE_DIRECT(block, GSN_FSWRITEREQ, signal,
FsReadWriteReq::FixedLength + 1,
instance // wl4391_todo This EXECUTE_DIRECT is thread safe
);
Uint32 size = request->par.open.page_size;
char* buf = (char*)m_page_ptr.p;
DWORD dwWritten;
while(size > 0){
BOOL bWrite= WriteFile(hFile, buf, size, &dwWritten, 0);
if(!bWrite || dwWritten!=size)
{
request->error= GetLastError();
}
size -= dwWritten;
buf += dwWritten;
}
if(size != 0)
{
int err = errno;
/* close(theFd);
unlink(theFileName.c_str());*/
request->error = err;
return;
}
off.QuadPart += request->par.open.page_size;
}
off.QuadPart= 0;
r= SetFilePointerEx(hFile, off, NULL, FILE_BEGIN);
if(r==0)
{
request->error= GetLastError();
return;
}
}
return;
}
void
DblqhProxy::execLQH_TRANSCONF(Signal* signal)
{
const LqhTransConf* conf = (const LqhTransConf*)signal->getDataPtr();
Uint32 ssId = conf->tcRef;
Ss_LQH_TRANSREQ& ss = ssFind<Ss_LQH_TRANSREQ>(ssId);
ss.m_conf = *conf;
BlockReference ref = signal->getSendersBlockRef();
ndbrequire(refToMain(ref) == number());
const Uint32 ino = refToInstance(ref);
const Uint32 worker = workerIndex(ino);
ndbrequire(ref == workerRef(worker));
ndbrequire(worker < c_workers);
if (ss.m_valid == false)
{
jam();
/**
* This is an in-flight signal to an old take-over "session"
*/
if (ss.m_conf.operationStatus == LqhTransConf::LastTransConf)
{
jam();
ndbrequire(ss.m_workerMask.get(worker));
ss.m_workerMask.clear(worker);
if (ss.m_workerMask.isclear())
{
jam();
ssRelease<Ss_LQH_TRANSREQ>(ssId);
}
}
return;
}
else if (ss.m_conf.operationStatus == LqhTransConf::LastTransConf)
{
jam();
/**
* When completing(LqhTransConf::LastTransConf) a LQH_TRANSREQ
* also check if one can release obsoleteded records
*
* This could have been done on each LQH_TRANSCONF, but there is no
* urgency, so it's ok todo only on LastTransConf
*/
Uint32 nodeId = ss.m_req.failedNodeId;
for (Uint32 i = 0; i<NDB_ARRAY_SIZE(c_ss_LQH_TRANSREQ.m_pool); i++)
{
if (c_ss_LQH_TRANSREQ.m_pool[i].m_ssId != 0 &&
c_ss_LQH_TRANSREQ.m_pool[i].m_ssId != ssId &&
c_ss_LQH_TRANSREQ.m_pool[i].m_req.failedNodeId == nodeId &&
c_ss_LQH_TRANSREQ.m_pool[i].m_valid == false)
{
jam();
if (c_ss_LQH_TRANSREQ.m_pool[i].m_workerMask.get(worker))
{
jam();
c_ss_LQH_TRANSREQ.m_pool[i].m_workerMask.clear(worker);
if (c_ss_LQH_TRANSREQ.m_pool[i].m_workerMask.isclear())
{
jam();
ssRelease<Ss_LQH_TRANSREQ>(c_ss_LQH_TRANSREQ.m_pool[i].m_ssId);
}
}
}
}
}
recvCONF(signal, ss);
}
