bool Dbinfo::find_next(Ndbinfo::ScanCursor* cursor) const { Uint32 node = refToNode(cursor->currRef); Uint32 block = refToBlock(cursor->currRef); const Uint32 instance = refToInstance(cursor->currRef); ndbrequire(instance == 0); if (node == 0) { jam(); // First 'find_next' ndbrequire(block == 0); cursor->currRef = switchRef(dbinfo_blocks[0], getOwnNodeId()); return true; } if (block) { jam(); // Find next block ndbrequire(node == getOwnNodeId()); block = find_next_block(block); if (block) { jam(); cursor->currRef = switchRef(block, node); return true; } } // Nothing more to scan cursor->currRef = 0; return false; }
/* * 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::execEXEC_SRCONF(Signal* signal) { const BlockReference senderRef = signal->getSendersBlockRef(); if (refToInstance(senderRef) != 0) { jam(); execEXEC_SR_2(signal, GSN_EXEC_SRCONF); return; } execEXEC_SR_1(signal, GSN_EXEC_SRCONF); }
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); }