void
DblqhProxy::sendLQHADDATTCONF(Signal* signal, Uint32 ssId)
{
Ss_LQHADDATTREQ& ss = ssFind<Ss_LQHADDATTREQ>(ssId);
Ss_CREATE_TAB_REQ& ss_main = ssFind<Ss_CREATE_TAB_REQ>(ssId);
BlockReference dictRef = ss_main.m_req.senderRef;
if (!lastReply(ss))
return;
if (ss.m_error == 0)
{
jam();
LqhAddAttrConf* conf = (LqhAddAttrConf*)signal->getDataPtrSend();
conf->senderData = ss.m_req.senderData;
conf->senderAttrPtr = ss.m_req.senderAttrPtr;
sendSignal(dictRef, GSN_LQHADDATTCONF,
signal, LqhAddAttrConf::SignalLength, JBB);
if (ss_main.m_req.noOfAttributes == 0)
{
jam();
/**
* All the attributes has been processed
* release create_table object
*/
ssRelease<Ss_CREATE_TAB_REQ>(ssId);
}
}
else
{
jam();
LqhAddAttrRef* ref = (LqhAddAttrRef*)signal->getDataPtrSend();
ref->senderData = ss.m_req.senderData;
ref->errorCode = ss.m_error;
sendSignal(dictRef, GSN_LQHADDATTREF,
signal, LqhAddAttrRef::SignalLength, JBB);
ssRelease<Ss_CREATE_TAB_REQ>(ssId);
}
ssRelease<Ss_LQHADDATTREQ>(ssId);
}
void
Dbtup::buildIndexReply(Signal* signal, const BuildIndexRec* buildPtrP)
{
const BuildIndxImplReq* buildReq = &buildPtrP->m_request;
AlterIndxImplReq* req = (AlterIndxImplReq*)signal->getDataPtrSend();
req->indexId = buildReq->indexId;
req->senderRef = 0; //
if (buildPtrP->m_errorCode == BuildIndxImplRef::NoError)
{
jam();
req->requestType = AlterIndxImplReq::AlterIndexOnline;
}
else
{
jam();
req->requestType = AlterIndxImplReq::AlterIndexOffline;
}
EXECUTE_DIRECT(DBTUX, GSN_ALTER_INDX_IMPL_REQ, signal,
AlterIndxImplReq::SignalLength);
if (buildPtrP->m_errorCode == BuildIndxImplRef::NoError) {
jam();
BuildIndxImplConf* conf =
(BuildIndxImplConf*)signal->getDataPtrSend();
conf->senderRef = reference();
conf->senderData = buildReq->senderData;
sendSignal(buildReq->senderRef, GSN_BUILD_INDX_IMPL_CONF,
signal, BuildIndxImplConf::SignalLength, JBB);
} else {
jam();
BuildIndxImplRef* ref =
(BuildIndxImplRef*)signal->getDataPtrSend();
ref->senderRef = reference();
ref->senderData = buildReq->senderData;
ref->errorCode = buildPtrP->m_errorCode;
sendSignal(buildReq->senderRef, GSN_BUILD_INDX_IMPL_REF,
signal, BuildIndxImplRef::SignalLength, JBB);
}
}
void
Dbtup::execDROP_TRIG_REQ(Signal* signal)
{
jamEntry();
BlockReference senderRef = signal->getSendersBlockRef();
const DropTrigReq reqCopy = *(const DropTrigReq*)signal->getDataPtr();
const DropTrigReq* const req = &reqCopy;
// Find table
TablerecPtr tabPtr;
tabPtr.i = req->getTableId();
ptrCheckGuard(tabPtr, cnoOfTablerec, tablerec);
// Drop trigger
Uint32 r = dropTrigger(tabPtr.p, req, refToBlock(senderRef));
if (r == 0){
// Send conf
DropTrigConf* const conf = (DropTrigConf*)signal->getDataPtrSend();
conf->setUserRef(senderRef);
conf->setConnectionPtr(req->getConnectionPtr());
conf->setRequestType(req->getRequestType());
conf->setTableId(req->getTableId());
conf->setIndexId(req->getIndexId());
conf->setTriggerId(req->getTriggerId());
sendSignal(senderRef, GSN_DROP_TRIG_CONF,
signal, DropTrigConf::SignalLength, JBB);
} else {
// Send ref
DropTrigRef* const ref = (DropTrigRef*)signal->getDataPtrSend();
ref->setUserRef(senderRef);
ref->setConnectionPtr(req->getConnectionPtr());
ref->setRequestType(req->getRequestType());
ref->setTableId(req->getTableId());
ref->setIndexId(req->getIndexId());
ref->setTriggerId(req->getTriggerId());
ref->setErrorCode((DropTrigRef::ErrorCode)r);
ref->setErrorLine(__LINE__);
ref->setErrorNode(refToNode(reference()));
sendSignal(senderRef, GSN_DROP_TRIG_REF,
signal, DropTrigRef::SignalLength, JBB);
}
}//Dbtup::DROP_TRIG_REQ()
void SensorFileSysWalker::sendNewDirectoryInfo() {
logger.logInfo( "sendNewDirectoryInfo: execute..." );
// send current directory list
StringList files;
getDirList( curDir , files );
for( int k = 0; k < files.count(); k++ ) {
String file = files.get( k );
sendSignal( SIGNAL_DIR_LISTITEM , file );
}
}
/*
* sigtstp_handler - The kernel sends a SIGTSTP to the shell whenever
* the user types ctrl-z at the keyboard. Catch it and suspend the
* foreground job by sending it a SIGTSTP.
*/
void sigtstp_handler(int sig)
{
pid_t pid;
pid = fgpid(job_list);
if(pid != 0){
sendSignal(sig, -pid);
}else{
printf("SIGINT misses\n");
}
return;
}
/*
* sigint_handler - The kernel sends a SIGINT to the shell whenver the
* user types ctrl-c at the keyboard. Catch it and send it along
* to the foreground job.
*/
void sigint_handler(int sig)
{
pid_t pid;
pid = fgpid(job_list);
if(pid != 0){
sendSignal(sig, -pid);
}else{
printf("heihei");
}
return;
}
bool TESession::closeSession()
{
autoClose = true;
wantedClose = true;
if (!sh->isRunning() || !sendSignal(SIGHUP))
{
// Forced close.
TQTimer::singleShot(1, this, TQT_SLOT(done()));
}
return true;
}
void
Restore::open_file(Signal* signal, FilePtr file_ptr)
{
signal->theData[0] = NDB_LE_StartReadLCP;
signal->theData[1] = file_ptr.p->m_table_id;
signal->theData[2] = file_ptr.p->m_fragment_id;
sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 3, JBB);
FsOpenReq * req = (FsOpenReq *)signal->getDataPtrSend();
req->userReference = reference();
req->fileFlags = FsOpenReq::OM_READONLY | FsOpenReq::OM_GZ;
req->userPointer = file_ptr.i;
FsOpenReq::setVersion(req->fileNumber, 5);
FsOpenReq::setSuffix(req->fileNumber, FsOpenReq::S_DATA);
FsOpenReq::v5_setLcpNo(req->fileNumber, file_ptr.p->m_lcp_no);
FsOpenReq::v5_setTableId(req->fileNumber, file_ptr.p->m_table_id);
FsOpenReq::v5_setFragmentId(req->fileNumber, file_ptr.p->m_fragment_id);
sendSignal(NDBFS_REF, GSN_FSOPENREQ, signal, FsOpenReq::SignalLength, JBA);
}
void eFilePushThread::stop()
{
/* if we aren't running, don't bother stopping. */
if (m_stop == 1)
return;
m_stop = 1;
eDebug("eFilePushThread stopping thread");
m_run_cond.signal(); /* Break out of pause if needed */
sendSignal(SIGUSR1);
kill(); /* Kill means join actually */
}
void Dbinfo::execINCL_NODEREQ(Signal* signal)
{
jamEntry();
const Uint32 senderRef = signal->theData[0];
const Uint32 inclNode = signal->theData[1];
signal->theData[0] = inclNode;
signal->theData[1] = reference();
sendSignal(senderRef, GSN_INCL_NODECONF, signal, 2, JBB);
}
// GSN_SUB_GCP_COMPLETE_REP
void
DblqhProxy::execSUB_GCP_COMPLETE_REP(Signal* signal)
{
jamEntry();
for (Uint32 i = 0; i<c_workers; i++)
{
jam();
sendSignal(workerRef(i), GSN_SUB_GCP_COMPLETE_REP, signal,
signal->getLength(), JBB);
}
}
void Program::signal(int sig)
{
#ifndef YUNI_OS_MSVC
auto envptr = pEnv;
if (!!envptr)
envptr->sendSignal(true, sig);
#else
// Signals are not supported on Windows. Silently ignoring it.
(void) sig;
#endif
}
/*!
* Main function.
*
* Creates a RedshiftEnabler object and connects it to the readyCheck dbus signal, so that if a new redshift plasmoid
* is created (this sends the readyCheck signal) this is enabled by this program. Moreover this program sends the
* readyForStart signal once launched to enable already existent redshift plasmoids during the login phase.
*/
int main(int argc, char *argv[])
{
QCoreApplication app(argc, argv);
RedshiftEnabler *enabler = new RedshiftEnabler();
//Responds to the readyCheck signal with a readyForStart signal
QDBusConnection dbus = QDBusConnection::sessionBus();
dbus.connect("", "/", "org.kde.redshift", "readyCheck",
enabler, SLOT(sendSignal()));
//Sends the signal once started to enable already possibly running instances of redshift data engine
enabler->sendSignal();
return app.exec();
}
void
PgmanProxy::send_data_file_ord(Signal* signal, Uint32 i, Uint32 ret,
Uint32 cmd, Uint32 file_no, Uint32 fd)
{
DataFileOrd* ord = (DataFileOrd*)signal->getDataPtrSend();
ord->ret = ret;
ord->cmd = cmd;
ord->file_no = file_no;
ord->fd = fd;
sendSignal(workerRef(i), GSN_DATA_FILE_ORD,
signal, DataFileOrd::SignalLength, JBB);
}
void
TrpmanProxy::execOPEN_COMORD(Signal* signal)
{
jamEntry();
for (Uint32 i = 0; i<c_workers; i++)
{
jam();
sendSignal(workerRef(i), GSN_OPEN_COMORD, signal,
signal->getLength(), JBB);
}
}
/**
* execROUTE_ORD
* Allows other blocks to route signals as if they
* came from TRPMAN
* Useful in ndbmtd for synchronising signals w.r.t
* external signals received from other nodes which
* arrive from the same thread that runs TRPMAN
*/
void
Trpman::execROUTE_ORD(Signal* signal)
{
jamEntry();
if (!assembleFragments(signal))
{
jam();
return;
}
SectionHandle handle(this, signal);
RouteOrd* ord = (RouteOrd*)signal->getDataPtr();
Uint32 dstRef = ord->dstRef;
Uint32 srcRef = ord->srcRef;
Uint32 gsn = ord->gsn;
/* ord->cnt ignored */
Uint32 nodeId = refToNode(dstRef);
if (likely((nodeId == 0) ||
getNodeInfo(nodeId).m_connected))
{
jam();
Uint32 secCount = handle.m_cnt;
ndbrequire(secCount >= 1 && secCount <= 3);
jamLine(secCount);
/**
* Put section 0 in signal->theData
*/
Uint32 sigLen = handle.m_ptr[0].sz;
ndbrequire(sigLen <= 25);
copy(signal->theData, handle.m_ptr[0]);
SegmentedSectionPtr save = handle.m_ptr[0];
for (Uint32 i = 0; i < secCount - 1; i++)
handle.m_ptr[i] = handle.m_ptr[i+1];
handle.m_cnt--;
sendSignal(dstRef, gsn, signal, sigLen, JBB, &handle);
handle.m_cnt = 1;
handle.m_ptr[0] = save;
releaseSections(handle);
return ;
}
releaseSections(handle);
warningEvent("Unable to route GSN: %d from %x to %x",
gsn, srcRef, dstRef);
}
void
DbgdmProxy::sendTC_SCHVERREQ(Signal* signal, Uint32 ssId, SectionHandle*)
{
Ss_TC_SCHVERREQ& ss = ssFind<Ss_TC_SCHVERREQ>(ssId);
TcSchVerReq* req = (TcSchVerReq*)signal->getDataPtrSend();
*req = ss.m_req;
req->senderRef = reference();
req->senderData = ssId;
sendSignal(workerRef(ss.m_worker), GSN_TC_SCHVERREQ,
signal, TcSchVerReq::SignalLength, JBB);
}
void
DbgdmProxy::sendDROP_TAB_REQ(Signal* signal, Uint32 ssId, SectionHandle*)
{
Ss_DROP_TAB_REQ& ss = ssFind<Ss_DROP_TAB_REQ>(ssId);
DropTabReq* req = (DropTabReq*)signal->getDataPtrSend();
*req = ss.m_req;
req->senderRef = reference();
req->senderData = ssId; // redundant since tableId is used
sendSignal(workerRef(ss.m_worker), GSN_DROP_TAB_REQ,
signal, DropTabReq::SignalLength, JBB);
}
void eFilePushThread::stop()
{
/* if we aren't running, don't bother stopping. */
if (!sync())
return;
m_stop = 1;
eDebug("eFilePushThread stopping thread");
sendSignal(SIGUSR1);
kill(0);
}
void
DbgdmProxy::sendTAB_COMMITREQ(Signal* signal, Uint32 ssId, SectionHandle*)
{
Ss_TAB_COMMITREQ& ss = ssFind<Ss_TAB_COMMITREQ>(ssId);
TabCommitReq* req = (TabCommitReq*)signal->getDataPtrSend();
req->senderRef = reference();
req->senderData = ssId;
req->tableId = ss.m_req.tableId;
sendSignal(workerRef(ss.m_worker), GSN_TAB_COMMITREQ,
signal, TabCommitReq::SignalLength, JBB);
}
void eFilePushThread::stop()
{
/* if we aren't running, don't bother stopping. */
if (!sync())
return;
m_stop = 1;
eDebug("stopping thread."); /* just do it ONCE. it won't help to do this more than once. */
sendSignal(SIGUSR1);
kill(0);
}
void
DbtcProxy::sendDROP_FK_IMPL_REQ(Signal* signal, Uint32 ssId, SectionHandle*)
{
Ss_DROP_FK_IMPL_REQ& ss = ssFind<Ss_DROP_FK_IMPL_REQ>(ssId);
DropFKImplReq* req = (DropFKImplReq*)signal->getDataPtrSend();
*req = ss.m_req;
req->senderRef = reference();
req->senderData = ssId;
sendSignal(workerRef(ss.m_worker), GSN_DROP_FK_IMPL_REQ,
signal, DropFKImplReq::SignalLength, JBB);
}
void
DbtcProxy::sendABORT_ALL_REQ(Signal* signal, Uint32 ssId, SectionHandle*)
{
Ss_ABORT_ALL_REQ& ss = ssFind<Ss_ABORT_ALL_REQ>(ssId);
AbortAllReq* req = (AbortAllReq*)signal->getDataPtrSend();
*req = ss.m_req;
req->senderRef = reference();
req->senderData = ssId;
sendSignal(workerRef(ss.m_worker), GSN_ABORT_ALL_REQ,
signal, AbortAllReq::SignalLength, JBB);
}
void
DblqhProxy::completeLCP_3(Signal* signal)
{
jamEntry();
ndbrequire(c_lcpRecord.m_state == LcpRecord::L_COMPLETING_2);
c_lcpRecord.m_state = LcpRecord::L_COMPLETING_3;
/**
* And finally also checkpoint UNDO LOG
* and inform TSMAN that checkpoint is "complete"
*/
EndLcpReq* req = (EndLcpReq*)signal->getDataPtrSend();
req->senderData= 0;
req->senderRef= reference();
req->backupPtr= 0;
req->backupId= c_lcpRecord.m_lcpId;
// no reply from this
sendSignal(TSMAN_REF, GSN_END_LCP_REQ, signal,
EndLcpReq::SignalLength, JBB);
if (c_lcpRecord.m_lcp_frag_rep_cnt)
{
jam();
c_lcpRecord.m_complete_outstanding++;
sendSignal(LGMAN_REF, GSN_END_LCP_REQ, signal,
EndLcpReq::SignalLength, JBB);
}
else
{
jam();
/**
* lgman does currently not like 0 fragments,
* cause then it does not get a LCP_FRAG_ORD
*
* this should change so that it gets this first (style)
*/
sendLCP_COMPLETE_REP(signal);
}
}
void
DblqhProxy::completeLCP_1(Signal* signal)
{
ndbrequire(c_lcpRecord.m_state == LcpRecord::L_RUNNING);
c_lcpRecord.m_state = LcpRecord::L_COMPLETING_1;
ndbrequire(c_lcpRecord.m_complete_outstanding == 0);
/**
* send LCP_FRAG_ORD (lastFragmentFlag = true)
* to all LQH instances...
* they will reply with LCP_COMPLETE_REP
*/
LcpFragOrd* ord = (LcpFragOrd*)signal->getDataPtrSend();
ord->lcpId = c_lcpRecord.m_lcpId;
ord->lastFragmentFlag = true;
for (Uint32 i = 0; i<c_workers; i++)
{
jam();
c_lcpRecord.m_complete_outstanding++;
sendSignal(workerRef(i), GSN_LCP_FRAG_ORD, signal,
LcpFragOrd::SignalLength, JBB);
}
/**
* send END_LCP_REQ to all pgman instances (except "extra" pgman)
* they will reply with END_LCP_CONF
*/
EndLcpReq* req = (EndLcpReq*)signal->getDataPtrSend();
req->senderData= 0;
req->senderRef= reference();
req->backupPtr= 0;
req->backupId= c_lcpRecord.m_lcpId;
for (Uint32 i = 0; i<c_workers; i++)
{
jam();
c_lcpRecord.m_complete_outstanding++;
sendSignal(numberToRef(PGMAN, workerInstance(i), getOwnNodeId()),
GSN_END_LCP_REQ, signal, EndLcpReq::SignalLength, JBB);
}
}
void Trix::checkParallelism(Signal* signal, SubscriptionRecord* subRec)
{
if ((subRec->pendingSubSyncContinueConf) &&
(subRec->expectedConf < subRec->parallelism)) {
SubSyncContinueConf * subSyncContinueConf =
(SubSyncContinueConf *) signal->getDataPtrSend();
subSyncContinueConf->subscriptionId = subRec->subscriptionId;
subSyncContinueConf->subscriptionKey = subRec->subscriptionKey;
sendSignal(SUMA_REF, GSN_SUB_SYNC_CONTINUE_CONF, signal,
SubSyncContinueConf::SignalLength , JBB);
subRec->pendingSubSyncContinueConf = false;
}
}
void Dbtup::storedProcBufferSeizeErrorLab(Signal* signal,
Operationrec* regOperPtr,
Uint32 storedProcPtr,
Uint32 errorCode)
{
regOperPtr->m_any_value = 0;
set_trans_state(regOperPtr, TRANS_ERROR_WAIT_STORED_PROCREQ);
signal->theData[0] = regOperPtr->userpointer;
signal->theData[1] = errorCode;
signal->theData[2] = storedProcPtr;
BlockReference lqhRef = calcInstanceBlockRef(DBLQH);
sendSignal(lqhRef, GSN_STORED_PROCREF, signal, 3, JBB);
}//Dbtup::storedSeizeAttrinbufrecErrorLab()
// GSN_EXEC_FRAGCONF
void
DblqhProxy::execEXEC_FRAGCONF(Signal* signal)
{
Uint32 ref = signal->theData[1];
if (refToNode(ref) == getOwnNodeId())
{
jam();
sendSignal(ref, GSN_EXEC_FRAGCONF, signal, 1, JBB);
}
else if (ndb_route_exec_frag(getNodeInfo(refToNode(ref)).m_version))
{
jam();
sendSignal(numberToRef(DBLQH, refToNode(ref)), GSN_EXEC_FRAGCONF,
signal, 2, JBB);
}
else
{
jam();
sendSignal(ref, GSN_EXEC_FRAGCONF, signal, 2, JBB);
}
}
void Cmvmi::execDISCONNECT_REP(Signal *signal)
{
const DisconnectRep * const rep = (DisconnectRep *)&signal->theData[0];
const Uint32 hostId = rep->nodeId;
const Uint32 errNo = rep->err;
jamEntry();
setNodeInfo(hostId).m_connected = false;
setNodeInfo(hostId).m_connectCount++;
const NodeInfo::NodeType type = getNodeInfo(hostId).getType();
ndbrequire(type != NodeInfo::INVALID);
sendSignal(QMGR_REF, GSN_DISCONNECT_REP, signal,
DisconnectRep::SignalLength, JBA);
cancelSubscription(hostId);
signal->theData[0] = NDB_LE_Disconnected;
signal->theData[1] = hostId;
sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 2, JBB);
}
void
DbtcProxy::sendGCP_NOMORETRANS(Signal* signal, Uint32 ssId, SectionHandle*)
{
Ss_GCP_NOMORETRANS& ss = ssFind<Ss_GCP_NOMORETRANS>(ssId);
GCPNoMoreTrans * req = (GCPNoMoreTrans*)signal->getDataPtrSend();
req->senderRef = reference();
req->senderData = ssId;
req->gci_hi = ss.m_req.gci_hi;
req->gci_lo = ss.m_req.gci_lo;
sendSignal(workerRef(ss.m_worker), GSN_GCP_NOMORETRANS,
signal, GCPNoMoreTrans::SignalLength, JBB);
}