| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // @@@ START COPYRIGHT @@@ |
| // |
| // Licensed to the Apache Software Foundation (ASF) under one |
| // or more contributor license agreements. See the NOTICE file |
| // distributed with this work for additional information |
| // regarding copyright ownership. The ASF licenses this file |
| // to you under the Apache License, Version 2.0 (the |
| // "License"); you may not use this file except in compliance |
| // with the License. You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, |
| // software distributed under the License is distributed on an |
| // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| // KIND, either express or implied. See the License for the |
| // specific language governing permissions and limitations |
| // under the License. |
| // |
| // @@@ END COPYRIGHT @@@ |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| #ifndef REQQUEUE_H_ |
| #define REQQUEUE_H_ |
| |
| #include <list> |
| using namespace std; |
| |
| #include "lock.h" |
| #include "monitor.h" |
| #include "config.h" |
| |
| #define MAX_REVIVE_QUEUE_SIZE 10000 |
| |
| class CReqResource |
| { |
| protected: |
| int eyecatcher_; // Debuggging aid -- leave as first |
| // member variable of the class |
| public: |
| CReqResource(); |
| virtual ~CReqResource(); |
| |
| typedef enum ResStat {UnAvailable, Acquired, Busy, NotUp} ResourceStatus_t; |
| |
| virtual ResourceStatus_t acquireResource( long requestId ) = 0; |
| virtual void releaseResource() = 0; |
| }; |
| |
| class CReqResourceProc: public CReqResource |
| { |
| public: |
| CReqResourceProc(int nid, int pid, const char *name, Verifier_t verifier ); |
| virtual ~CReqResourceProc(); |
| |
| ResourceStatus_t acquireResource( long requestId ); |
| void releaseResource(); |
| CProcess* getProcess(); |
| |
| private: |
| CReqResourceProc(); |
| int nid_; |
| int pid_; |
| Verifier_t verifier_; |
| string processName_; |
| }; |
| |
| class CReqResourceConfig: public CReqResource |
| { |
| public: |
| CReqResourceConfig(CConfigGroup *config); |
| virtual ~CReqResourceConfig(); |
| |
| ResourceStatus_t acquireResource( long requestId ); |
| void releaseResource(); |
| |
| private: |
| CReqResourceConfig(); |
| // tbd: should be CConfigGroup or CConfigKey? |
| CConfigGroup* config_; |
| }; |
| |
| class CRequest |
| { |
| protected: |
| int eyecatcher_; // Debuggging aid -- leave as first |
| // member variable of the class |
| // (see comment block at end of file for |
| // assignments). |
| public: |
| CRequest(); |
| virtual ~CRequest(); |
| |
| virtual void performRequest() = 0; |
| const char *requestString() { return( requestString_.c_str() ); } |
| |
| virtual bool isExclusive() { return concurrent_ == false; } |
| virtual bool isSyncDependent() = 0; |
| virtual bool isShutdown() = 0; |
| virtual bool prepare() { return true; } |
| virtual bool takeOwnership( bool & ownershipFailure ) = 0; |
| virtual void giveupOwnership() = 0; |
| virtual void errorReply( int rc ) = 0; |
| void evalReqPerformance( void ); |
| struct timespec startTime () { return reqStart_; } |
| |
| void setConcurrent(bool reqType) { concurrent_ = reqType; } |
| |
| void addResource(CReqResource *); |
| |
| void setId(long id) { id_ = id; } |
| long getId() { return id_; } |
| |
| #ifdef NAMESERVER_PROCESS |
| static void monreply(struct message_def *msg, int sockFd, int *error = NULL); |
| #else |
| static void lioreply(struct message_def *msg, int Pid, int *error = NULL); |
| #endif |
| |
| void timeDiff ( struct timespec t1, struct timespec t2, |
| struct timespec &tDiff ); |
| |
| typedef enum ReqStatus {OkToExec, WaitToExec, Failed} ReqStatus_t; |
| ReqStatus_t okToExecute(); |
| virtual void validateObj( void ) = 0; |
| |
| int getExecTimeMax() { return execTimeMax_; } |
| |
| typedef enum ReqPriority {Normal, High} ReqPriority_t; |
| ReqPriority_t getPriority() { return priority_; } |
| void setPriority(ReqPriority_t priority) { priority_ = priority; } |
| |
| virtual void populateRequestString( void ) = 0; |
| |
| private: |
| bool concurrent_; // true if request can be executed concurrently |
| // with others. |
| |
| struct timespec reqArrival_; |
| struct timespec reqStart_; |
| |
| protected: |
| long id_; |
| int numResources_; |
| static const int MAX_RESOURCES=5; |
| CReqResource * resources_[MAX_RESOURCES]; |
| string requestString_; |
| int execTimeMax_; // maximum execution time allowed |
| |
| ReqPriority_t priority_; |
| }; |
| |
| class CExternalReq: public CRequest |
| { |
| public: |
| typedef enum |
| { |
| AttachStartupMsg, |
| StartupMsg, |
| NonStartupMsg, |
| ShutdownWork |
| } reqQueueMsg_t; |
| |
| CExternalReq( reqQueueMsg_t msgType |
| , int pid |
| , struct message_def *msg) |
| : msgType_(msgType) |
| , nid_(-1) |
| , pid_(pid) |
| , verifier_(-1) |
| , sockFd_(-1) |
| , msg_(msg) |
| , reqType_(msg?msg->u.request.type:ReqType_Invalid) {} |
| CExternalReq( reqQueueMsg_t msgType |
| , int nid |
| , int pid |
| , int sockFd |
| , struct message_def *msg) |
| : msgType_(msgType) |
| , nid_(nid) |
| , pid_(pid) |
| , verifier_(-1) |
| , sockFd_(sockFd) |
| , msg_(msg) |
| , reqType_(msg?msg->u.request.type:ReqType_Invalid) {} |
| |
| virtual ~CExternalReq() {} |
| |
| virtual void performRequest() = 0; |
| bool isSyncDependent() { return false; } |
| bool isShutdown() { return msgType_ == ShutdownWork; } |
| bool takeOwnership( bool & ownershipFailure ); |
| void giveupOwnership(); |
| bool setResourceNeeds(); |
| void errorReply( int rc ); |
| void validateObj( void ); |
| |
| private: |
| void errorOpenReq(struct message_def * msg); |
| |
| protected: |
| reqQueueMsg_t msgType_; |
| int nid_; |
| int pid_; |
| Verifier_t verifier_; |
| int sockFd_; |
| string processName_; |
| struct message_def * msg_; |
| // Request save data |
| REQTYPE reqType_; |
| }; |
| |
| #ifndef NAMESERVER_PROCESS |
| class CExtAttachStartupReq: public CExternalReq |
| { |
| public: |
| CExtAttachStartupReq (reqQueueMsg_t msgType, int pid, |
| struct message_def *msg ); |
| virtual ~CExtAttachStartupReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| }; |
| #endif |
| |
| #ifndef NAMESERVER_PROCESS |
| class CExtDumpReq: public CExternalReq |
| { |
| public: |
| CExtDumpReq (reqQueueMsg_t msgType, int pid, |
| struct message_def *msg ); |
| virtual ~CExtDumpReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| }; |
| #endif |
| |
| #ifndef NAMESERVER_PROCESS |
| class CExtNodeNameReq: public CExternalReq |
| { |
| public: |
| CExtNodeNameReq (reqQueueMsg_t msgType, int pid, |
| struct message_def *msg ); |
| virtual ~CExtNodeNameReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| }; |
| #endif |
| |
| #ifndef NAMESERVER_PROCESS |
| class CExtEventReq: public CExternalReq |
| { |
| public: |
| CExtEventReq (reqQueueMsg_t msgType, int pid, |
| struct message_def *msg ); |
| virtual ~CExtEventReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| }; |
| #endif |
| |
| #ifndef NAMESERVER_PROCESS |
| class CExtExitReq: public CExternalReq |
| { |
| public: |
| CExtExitReq (reqQueueMsg_t msgType, int pid, |
| struct message_def *msg ); |
| virtual ~CExtExitReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| }; |
| #endif |
| |
| #ifndef NAMESERVER_PROCESS |
| class CExtGetReq: public CExternalReq |
| { |
| public: |
| CExtGetReq (reqQueueMsg_t msgType, int pid, |
| struct message_def *msg ); |
| virtual ~CExtGetReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| }; |
| #endif |
| |
| class CExtKillReq: public CExternalReq |
| { |
| public: |
| CExtKillReq (reqQueueMsg_t msgType, int pid, |
| struct message_def *msg ); |
| virtual ~CExtKillReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| void Kill( CProcess *process ); |
| }; |
| |
| #ifndef NAMESERVER_PROCESS |
| class CExtMonStatsReq: public CExternalReq |
| { |
| public: |
| CExtMonStatsReq (reqQueueMsg_t msgType, int pid, |
| struct message_def *msg ); |
| virtual ~CExtMonStatsReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| }; |
| #endif |
| |
| #ifndef NAMESERVER_PROCESS |
| class CExtMountReq: public CExternalReq |
| { |
| public: |
| CExtMountReq (reqQueueMsg_t msgType, int pid, |
| struct message_def *msg ); |
| virtual ~CExtMountReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| }; |
| #endif |
| |
| #ifdef NAMESERVER_PROCESS |
| class CExtNameServerStartNsReq: public CExternalReq |
| { |
| public: |
| CExtNameServerStartNsReq (reqQueueMsg_t msgType, |
| int nid, int pid, int sockFd, |
| struct message_def *msg ); |
| virtual ~CExtNameServerStartNsReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| }; |
| #endif |
| |
| #ifdef NAMESERVER_PROCESS |
| class CExtNameServerStopNsReq: public CExternalReq |
| { |
| public: |
| CExtNameServerStopNsReq (reqQueueMsg_t msgType, |
| int nid, int pid, int sockFd, |
| struct message_def *msg ); |
| virtual ~CExtNameServerStopNsReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| }; |
| #endif |
| |
| #ifdef NAMESERVER_PROCESS |
| class CExtNewProcNsReq: public CExternalReq |
| { |
| public: |
| CExtNewProcNsReq (reqQueueMsg_t msgType, |
| int nid, int pid, int sockFd, |
| struct message_def *msg ); |
| virtual ~CExtNewProcNsReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| }; |
| #endif |
| |
| #ifndef NAMESERVER_PROCESS |
| class CExtNewProcReq: public CExternalReq |
| { |
| public: |
| CExtNewProcReq (reqQueueMsg_t msgType, |
| int nid, int pid, int sockFd, |
| struct message_def *msg ); |
| virtual ~CExtNewProcReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| }; |
| #endif |
| |
| #ifndef NAMESERVER_PROCESS |
| class CExtNodeAddReq: public CExternalReq |
| { |
| public: |
| CExtNodeAddReq (reqQueueMsg_t msgType, int pid, |
| struct message_def *msg ); |
| virtual ~CExtNodeAddReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| }; |
| #endif |
| |
| #ifndef NAMESERVER_PROCESS |
| class CExtNodeDeleteReq: public CExternalReq |
| { |
| public: |
| CExtNodeDeleteReq (reqQueueMsg_t msgType, int pid, |
| struct message_def *msg ); |
| virtual ~CExtNodeDeleteReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| }; |
| #endif |
| |
| #ifndef NAMESERVER_PROCESS |
| class CExtNodeDownReq: public CExternalReq |
| { |
| public: |
| CExtNodeDownReq (reqQueueMsg_t msgType, int pid, |
| struct message_def *msg ); |
| virtual ~CExtNodeDownReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| }; |
| #endif |
| |
| #ifdef NAMESERVER_PROCESS |
| class CExtNodeDownNsReq: public CExternalReq |
| { |
| public: |
| CExtNodeDownNsReq( reqQueueMsg_t msgType |
| , int pid |
| , int sockFd |
| , struct message_def *msg ); |
| virtual ~CExtNodeDownNsReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| }; |
| #endif |
| |
| #ifndef NAMESERVER_PROCESS |
| class CExtNameServerAddReq: public CExternalReq |
| { |
| public: |
| CExtNameServerAddReq (reqQueueMsg_t msgType, int pid, |
| struct message_def *msg ); |
| virtual ~CExtNameServerAddReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| }; |
| #endif |
| |
| #ifndef NAMESERVER_PROCESS |
| class CExtNameServerDeleteReq: public CExternalReq |
| { |
| public: |
| CExtNameServerDeleteReq (reqQueueMsg_t msgType, int pid, |
| struct message_def *msg ); |
| virtual ~CExtNameServerDeleteReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| }; |
| #endif |
| |
| #ifndef NAMESERVER_PROCESS |
| class CExtNameServerStartReq: public CExternalReq |
| { |
| public: |
| CExtNameServerStartReq (reqQueueMsg_t msgType, int pid, |
| struct message_def *msg ); |
| virtual ~CExtNameServerStartReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| }; |
| #endif |
| |
| #ifndef NAMESERVER_PROCESS |
| class CExtNameServerStopReq: public CExternalReq |
| { |
| public: |
| CExtNameServerStopReq (reqQueueMsg_t msgType, int pid, |
| struct message_def *msg ); |
| virtual ~CExtNameServerStopReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| }; |
| #endif |
| |
| #ifndef NAMESERVER_PROCESS |
| class CExtNodeInfoReq: public CExternalReq |
| { |
| public: |
| CExtNodeInfoReq (reqQueueMsg_t msgType, int pid, |
| struct message_def *msg ); |
| virtual ~CExtNodeInfoReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| }; |
| #endif |
| |
| #ifndef NAMESERVER_PROCESS |
| class CExtPNodeInfoReq: public CExternalReq |
| { |
| public: |
| CExtPNodeInfoReq (reqQueueMsg_t msgType, int pid, |
| struct message_def *msg ); |
| virtual ~CExtPNodeInfoReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| }; |
| #endif |
| |
| #ifndef NAMESERVER_PROCESS |
| class CExtNodeUpReq: public CExternalReq |
| { |
| public: |
| CExtNodeUpReq (reqQueueMsg_t msgType, int pid, |
| struct message_def *msg ); |
| virtual ~CExtNodeUpReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| }; |
| #endif |
| |
| #ifndef NAMESERVER_PROCESS |
| class CExtNotifyReq: public CExternalReq |
| { |
| public: |
| CExtNotifyReq (reqQueueMsg_t msgType, int pid, |
| struct message_def *msg ); |
| virtual ~CExtNotifyReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| }; |
| #endif |
| |
| class CExtNullReq: public CExternalReq |
| { |
| public: |
| CExtNullReq (reqQueueMsg_t msgType, |
| int nid, int pid, int sockFd, |
| struct message_def *msg ); |
| virtual ~CExtNullReq(); |
| |
| void performRequest() {} |
| |
| private: |
| void populateRequestString( void ){} |
| }; |
| |
| #ifndef NAMESERVER_PROCESS |
| class CExtOpenReq: public CExternalReq |
| { |
| public: |
| CExtOpenReq(reqQueueMsg_t msgType, int pid, struct message_def *msg); |
| virtual ~CExtOpenReq(); |
| |
| bool prepare(); |
| void performRequest(); |
| bool prepareRequest(); |
| void errorReply( int rc ); |
| |
| private: |
| bool prepared_; |
| CExtOpenReq(); |
| void populateRequestString( void ); |
| }; |
| #endif |
| |
| class CExtProcInfoBase: public CExternalReq |
| { |
| public: |
| CExtProcInfoBase (reqQueueMsg_t msgType, |
| int nid, int pid, int sockFd, |
| struct message_def *msg ) |
| : CExternalReq(msgType, nid, pid, sockFd, msg) {} |
| virtual ~CExtProcInfoBase() {} |
| |
| protected: |
| void ProcessInfo_CopyPairData( CProcess *process |
| , ProcessInfoState &procState ); |
| void ProcessInfo_CopyData(CProcess *process, ProcessInfoState &procState); |
| |
| CProcess * ProcessInfo_GetProcess (int &nid, bool getDataForAllNodes); |
| int ProcessInfo_BuildReply(CProcess *process, |
| struct message_def * msg, |
| PROCESSTYPE type, |
| bool getDataForAllNodes, |
| char *pattern); |
| }; |
| |
| class CExtProcInfoReq: public CExtProcInfoBase |
| { |
| public: |
| CExtProcInfoReq (reqQueueMsg_t msgType, |
| int nid, int pid, int sockFd, |
| struct message_def *msg ); |
| virtual ~CExtProcInfoReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| }; |
| |
| class CExtProcInfoContReq: public CExtProcInfoBase |
| { |
| public: |
| CExtProcInfoContReq (reqQueueMsg_t msgType, |
| int nid, int pid, int sockFd, |
| struct message_def *msg ); |
| virtual ~CExtProcInfoContReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| }; |
| |
| #ifdef NAMESERVER_PROCESS |
| |
| class CExtProcInfoNsReq: public CExternalReq |
| { |
| public: |
| CExtProcInfoNsReq( reqQueueMsg_t msgType, |
| int nid, int pid, int sockFd, |
| struct message_def *msg ); |
| virtual ~CExtProcInfoNsReq(); |
| |
| void performRequest(); |
| |
| private: |
| void copyInfo(CProcess *process, ProcessInfoNs_reply_def &procInfo); |
| void populateRequestString( void ); |
| }; |
| #endif |
| |
| #ifndef NAMESERVER_PROCESS |
| class CExtSetReq: public CExternalReq |
| { |
| public: |
| CExtSetReq (reqQueueMsg_t msgType, int pid, |
| struct message_def *msg ); |
| virtual ~CExtSetReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| }; |
| #endif |
| |
| #ifndef NAMESERVER_PROCESS |
| class CExtShutdownReq: public CExternalReq |
| { |
| public: |
| CExtShutdownReq (reqQueueMsg_t msgType, int pid, |
| struct message_def *msg ); |
| virtual ~CExtShutdownReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| }; |
| #endif |
| |
| #ifdef NAMESERVER_PROCESS |
| class CExtShutdownNsReq: public CExternalReq |
| { |
| public: |
| CExtShutdownNsReq (reqQueueMsg_t msgType, |
| int nid, int pid, int sockFd, |
| struct message_def *msg ); |
| virtual ~CExtShutdownNsReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| }; |
| #endif |
| |
| #ifndef NAMESERVER_PROCESS |
| class CExtStartupReq: public CExternalReq |
| { |
| public: |
| CExtStartupReq (reqQueueMsg_t msgType, int pid, |
| struct message_def *msg ); |
| virtual ~CExtStartupReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| }; |
| #endif |
| |
| #ifndef NAMESERVER_PROCESS |
| class CExtTmLeaderReq: public CExternalReq |
| { |
| public: |
| CExtTmLeaderReq (reqQueueMsg_t msgType, int pid, |
| struct message_def *msg ); |
| virtual ~CExtTmLeaderReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| }; |
| #endif |
| |
| #ifndef NAMESERVER_PROCESS |
| class CExtTmReadyReq: public CExternalReq |
| { |
| public: |
| CExtTmReadyReq(reqQueueMsg_t msgType, int pid, |
| struct message_def *msg ); |
| virtual ~CExtTmReadyReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| |
| int nid_; |
| }; |
| #endif |
| |
| #ifndef NAMESERVER_PROCESS |
| class CExtTmSyncReq: public CExternalReq |
| { |
| public: |
| CExtTmSyncReq (reqQueueMsg_t msgType, int pid, |
| struct message_def *msg ); |
| virtual ~CExtTmSyncReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| }; |
| #endif |
| |
| #ifndef NAMESERVER_PROCESS |
| class CExtZoneInfoReq: public CExternalReq |
| { |
| public: |
| CExtZoneInfoReq (reqQueueMsg_t msgType, int pid, |
| struct message_def *msg ); |
| virtual ~CExtZoneInfoReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| }; |
| #endif |
| |
| class CInternalReq: public CRequest |
| { |
| public: |
| CInternalReq(); |
| virtual ~CInternalReq(); |
| |
| void performRequest(); |
| bool isSyncDependent() { return true; } |
| bool isShutdown() { return false; } |
| bool takeOwnership( bool & ) { return true; } |
| void giveupOwnership(); |
| void errorReply( int rc ); |
| void validateObj( void ); |
| |
| void populateRequestString( void ); |
| |
| void setSeqNum( unsigned long long seqNum ) { seqNum_ = seqNum; } |
| unsigned long long getSeqNum() { return seqNum_; } |
| int GetReviveFlag() { return reviveFlag_; } |
| void SetReviveFlag(int value) { reviveFlag_ = value; } |
| |
| private: |
| |
| unsigned long long seqNum_; |
| int reviveFlag_; // set if this request is needed for revive operation |
| }; |
| |
| |
| #ifndef NAMESERVER_PROCESS |
| class CIntCloneProcReq: public CInternalReq |
| { |
| public: |
| CIntCloneProcReq( bool backup, bool unhooked, bool eventMessages, bool systemMessages, int nid, PROCESSTYPE type, int priority, int parentNid, int parentPid, int parentVerifier, int osPid, int verifier, pid_t priorPid, int persistentRetries, int argc, struct timespec creationTime, strId_t pathStrId, strId_t ldpathStrId, strId_t programStrId, int nameLen, int portLen, int infileLen, int outfileLen, int argvLen, const char * stringData, int origPNidNs); |
| virtual ~CIntCloneProcReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| |
| bool backup_; |
| bool unhooked_; |
| bool eventMessages_; |
| bool systemMessages_; |
| int nid_; |
| PROCESSTYPE type_; |
| int priority_; |
| int parentNid_; |
| int parentPid_; |
| int parentVerifier_; |
| int osPid_; |
| int verifier_; |
| pid_t priorPid_; |
| int persistentRetries_; |
| int argc_; |
| struct timespec creationTime_; |
| strId_t pathStrId_; |
| strId_t ldpathStrId_; |
| strId_t programStrId_; |
| int nameLen_; |
| int portLen_; |
| int infileLen_; |
| int outfileLen_; |
| int argvLen_; |
| char * stringData_; |
| int origPNidNs_; |
| }; |
| #endif |
| |
| #ifdef NAMESERVER_PROCESS |
| class CIntCloneProcNsReq: public CInternalReq |
| { |
| public: |
| CIntCloneProcNsReq( bool backup |
| , bool unhooked |
| , bool eventMessages |
| , bool systemMessages |
| , int nid |
| , PROCESSTYPE type |
| , int priority |
| , int parentNid |
| , int parentPid |
| , int parentVerifier |
| , int osPid |
| , int verifier |
| , pid_t priorPid |
| , int persistentRetries |
| , int argc |
| , struct timespec creationTime |
| , int pathLen |
| , int ldpathLen |
| , int programLen |
| , int nameLen |
| , int portLen |
| , int infileLen |
| , int outfileLen |
| , int argvLen |
| , const char * stringData |
| , int origPNidNs); |
| // CIntCloneProcNsReq( bool backup, bool unhooked, bool eventMessages, bool systemMessages, int nid, PROCESSTYPE type, int priority, int parentNid, int parentPid, int parentVerifier, int osPid, int verifier, pid_t priorPid, int persistentRetries, int argc, struct timespec creationTime, strId_t pathStrId, strId_t ldpathStrId, strId_t programStrId, int nameLen, int portLen, int infileLen, int outfileLen, int argvLen, const char * stringData, int origPNidNs); |
| virtual ~CIntCloneProcNsReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| |
| bool backup_; |
| bool unhooked_; |
| bool eventMessages_; |
| bool systemMessages_; |
| int nid_; |
| PROCESSTYPE type_; |
| int priority_; |
| int parentNid_; |
| int parentPid_; |
| int parentVerifier_; |
| int osPid_; |
| int verifier_; |
| pid_t priorPid_; |
| int persistentRetries_; |
| int argc_; |
| struct timespec creationTime_; |
| int pathLen_; |
| int ldpathLen_; |
| int programLen_; |
| // strId_t pathStrId_; |
| // strId_t ldpathStrId_; |
| // strId_t programStrId_; |
| int nameLen_; |
| int portLen_; |
| int infileLen_; |
| int outfileLen_; |
| int argvLen_; |
| char * stringData_; |
| int origPNidNs_; |
| }; |
| #endif |
| |
| #ifndef NAMESERVER_PROCESS |
| class CIntDeviceReq: public CInternalReq |
| { |
| public: |
| CIntDeviceReq( char *ldevName ); |
| virtual ~CIntDeviceReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| |
| char ldevName_[MAX_KEY_NAME]; // Logical device name |
| }; |
| #endif |
| |
| #ifndef NAMESERVER_PROCESS |
| class CIntExitReq: public CInternalReq |
| { |
| public: |
| CIntExitReq(); |
| virtual ~CIntExitReq(); |
| |
| void prepRequest( struct exit_def *exitDef ); |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| |
| int nid_; |
| int pid_; |
| Verifier_t verifier_; |
| bool abended_; |
| char name_[MAX_PROCESS_NAME]; |
| }; |
| #endif |
| |
| #ifdef NAMESERVER_PROCESS |
| class CIntExitNsReq: public CInternalReq |
| { |
| public: |
| CIntExitNsReq(); |
| virtual ~CIntExitNsReq(); |
| |
| void prepRequest( struct exit_ns_def *exitDef ); |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| |
| int nid_; |
| int pid_; |
| Verifier_t verifier_; |
| bool abended_; |
| char name_[MAX_PROCESS_NAME]; |
| struct message_def *msg_; |
| int sockFd_; |
| int origPNid_; |
| }; |
| #endif |
| |
| #ifdef NAMESERVER_PROCESS |
| class CExtDelProcessNsReq: public CExternalReq |
| { |
| public: |
| CExtDelProcessNsReq (reqQueueMsg_t msgType, |
| int nid, int pid, int sockFd, |
| struct message_def *msg ); |
| virtual ~CExtDelProcessNsReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| }; |
| #endif |
| |
| #ifndef NAMESERVER_PROCESS |
| class CIntIoDataReq: public CInternalReq |
| { |
| public: |
| CIntIoDataReq( ioData_t *ioData ); |
| virtual ~CIntIoDataReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| |
| int nid_; |
| int pid_; |
| Verifier_t verifier_; |
| StdIoType ioType_; |
| int length_; // Length in bytes of Data buffer used |
| char data_[MAX_SYNC_DATA]; |
| }; |
| #endif |
| |
| #ifndef NAMESERVER_PROCESS |
| class CIntKillReq: public CInternalReq |
| { |
| public: |
| CIntKillReq( struct kill_def *killDef ); |
| virtual ~CIntKillReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| |
| int nid_; |
| int pid_; |
| Verifier_t verifier_; |
| bool abort_; |
| }; |
| #endif |
| |
| #ifndef NAMESERVER_PROCESS |
| class CIntNewProcReq: public CInternalReq |
| { |
| public: |
| CIntNewProcReq( int nid |
| , PROCESSTYPE type |
| , int priority |
| , int backup |
| , int parentNid |
| , int parentPid |
| , Verifier_t parentVerifier |
| , int pairParentNid |
| , int pairParentPid |
| , Verifier_t pairParentVerifier |
| , int argc |
| , bool unhooked |
| , void *reqTag |
| , strId_t pathStrId |
| , strId_t ldpathStrId |
| , strId_t programStrId |
| , int nameLen |
| , int infileLen |
| , int outfileLen |
| , int argvLen |
| , const char* stringData ); |
| virtual ~CIntNewProcReq ( ); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| |
| int nid_; |
| PROCESSTYPE type_; |
| int priority_; |
| int backup_; |
| int parentNid_; |
| int parentPid_; |
| Verifier_t parentVerifier_; |
| int pairParentNid_; |
| int pairParentPid_; |
| Verifier_t pairParentVerifier_; |
| int argc_; |
| bool unhooked_; |
| void *reqTag_; |
| strId_t pathStrId_; |
| strId_t ldpathStrId_; |
| strId_t programStrId_; |
| int nameLen_; |
| int infileLen_; |
| int outfileLen_; |
| int argvLen_; |
| char* stringData_; |
| }; |
| #endif |
| |
| #ifdef NAMESERVER_PROCESS |
| class CIntNewProcNsReq: public CInternalReq |
| { |
| public: |
| CIntNewProcNsReq( int nid |
| , int pid |
| , Verifier_t verifier |
| , PROCESSTYPE type |
| , int priority |
| , int backup |
| , int parentNid |
| , int parentPid |
| , Verifier_t parentVerifier |
| , int pairParentNid |
| , int pairParentPid |
| , Verifier_t pairParentVerifier |
| , int argc |
| , bool unhooked |
| , void* reqTag |
| , int pathLen |
| , int ldpathLen |
| , int programLen |
| , int nameLen |
| , int infileLen |
| , int outfileLen |
| , int argvLen |
| , const char* stringData ); |
| virtual ~CIntNewProcNsReq ( ); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| |
| int nid_; |
| int pid_; |
| Verifier_t verifier_; |
| PROCESSTYPE type_; |
| int priority_; |
| int backup_; |
| int parentNid_; |
| int parentPid_; |
| Verifier_t parentVerifier_; |
| int pairParentNid_; |
| int pairParentPid_; |
| Verifier_t pairParentVerifier_; |
| int argc_; |
| bool unhooked_; |
| void *reqTag_; |
| int pathLen_; |
| int ldpathLen_; |
| int programLen_; |
| int nameLen_; |
| int infileLen_; |
| int outfileLen_; |
| int argvLen_; |
| char* stringData_; |
| }; |
| #endif |
| |
| class CIntNotifyReq: public CInternalReq |
| { |
| public: |
| CIntNotifyReq( struct notify_def *notifyDef ); |
| virtual ~CIntNotifyReq( ); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| |
| int nid_; |
| int pid_; |
| Verifier_t verifier_; |
| bool canceled_; |
| int targetNid_; |
| int targetPid_; |
| Verifier_t targetVerifier_; |
| _TM_Txid_External transId_; |
| }; |
| |
| |
| class CIntOpenReq: public CInternalReq |
| { |
| public: |
| CIntOpenReq ( struct open_def *openDef ); |
| virtual ~CIntOpenReq ( ); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| |
| int openerNid_; |
| int openerPid_; |
| Verifier_t openerVerifier_; |
| int openedNid_; |
| int openedPid_; |
| Verifier_t openedVerifier_; |
| }; |
| |
| |
| class CIntProcInitReq: public CInternalReq |
| { |
| public: |
| CIntProcInitReq ( struct process_init_def *procInitDef ); |
| virtual ~CIntProcInitReq ( ); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| |
| int nid_; |
| int pid_; |
| Verifier_t verifier_; |
| STATE state_; |
| int result_; |
| CProcess *process_; |
| char name_[MAX_PROCESS_NAME]; |
| }; |
| |
| class CIntSetReq: public CInternalReq |
| { |
| public: |
| CIntSetReq ( ConfigType type, const char *group, const char *key, |
| const char *value ); |
| virtual ~CIntSetReq ( ); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| |
| ConfigType type_; |
| char group_[MAX_KEY_NAME]; |
| char key_[MAX_KEY_NAME]; |
| char value_[MAX_VALUE_SIZE_INT]; |
| }; |
| |
| #ifndef NAMESERVER_PROCESS |
| class CIntStdInReq: public CInternalReq |
| { |
| public: |
| CIntStdInReq( struct stdin_req_def *stdin_req ); |
| virtual ~CIntStdInReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| |
| int nid_; |
| int pid_; |
| Verifier_t verifier_; |
| StdinReqType reqType_; |
| int supplierNid_; // Node id of process supplying stdin data |
| int supplierPid_; // Process id of process to supplying stdin data |
| }; |
| #endif |
| |
| class CIntUniqStrReq: public CInternalReq |
| { |
| public: |
| CIntUniqStrReq ( int nid, int id, const char *value ); |
| virtual ~CIntUniqStrReq ( ); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| |
| int nid_; |
| int id_; |
| char value_[MAX_VALUE_SIZE_INT]; |
| }; |
| |
| |
| class CIntChildDeathReq: public CInternalReq |
| { |
| public: |
| CIntChildDeathReq ( pid_t pid ); |
| virtual ~CIntChildDeathReq ( ); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| |
| pid_t pid_; |
| CProcess * process_; |
| }; |
| |
| class CIntAttachedDeathReq: public CInternalReq |
| { |
| public: |
| CIntAttachedDeathReq ( pid_t pid ); |
| virtual ~CIntAttachedDeathReq ( ); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| |
| pid_t pid_; |
| }; |
| |
| class CIntShutdownReq: public CInternalReq |
| { |
| public: |
| CIntShutdownReq( int level ); |
| virtual ~CIntShutdownReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| |
| int level_; |
| }; |
| |
| class CIntNameServerAddReq: public CInternalReq |
| { |
| public: |
| CIntNameServerAddReq( int req_nid |
| , int req_pid |
| , Verifier_t req_verifier |
| , char *nodeName |
| ); |
| virtual ~CIntNameServerAddReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| |
| int req_nid_; |
| int req_pid_; |
| Verifier_t req_verifier_; |
| char nodeName_[MPI_MAX_PROCESSOR_NAME]; |
| }; |
| |
| class CIntNameServerDeleteReq: public CInternalReq |
| { |
| public: |
| CIntNameServerDeleteReq( int req_nid |
| , int req_pid |
| , Verifier_t req_verifier |
| , const char *nodeName ); |
| virtual ~CIntNameServerDeleteReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| |
| int req_nid_; |
| int req_pid_; |
| Verifier_t req_verifier_; |
| char nodeName_[MPI_MAX_PROCESSOR_NAME]; |
| }; |
| |
| class CIntNodeNameReq: public CInternalReq |
| { |
| public: |
| CIntNodeNameReq( int req_nid |
| , int req_pid |
| , Verifier_t req_verifier |
| , const char *current_name |
| , const char *new_name ); |
| virtual ~CIntNodeNameReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| |
| int req_nid_; |
| int req_pid_; |
| Verifier_t req_verifier_; |
| string current_name_; |
| string new_name_; |
| }; |
| |
| class CIntNodeAddReq: public CInternalReq |
| { |
| public: |
| CIntNodeAddReq( int req_nid |
| , int req_pid |
| , Verifier_t req_verifier |
| , char *nodeName |
| , int firstCore |
| , int lastCore |
| , int processors |
| , int roles |
| ); |
| virtual ~CIntNodeAddReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| |
| int req_nid_; |
| int req_pid_; |
| Verifier_t req_verifier_; |
| char nodeName_[MPI_MAX_PROCESSOR_NAME]; |
| int first_core_; |
| int last_core_; |
| int processors_; |
| int roles_; |
| }; |
| |
| class CIntNodeDeleteReq: public CInternalReq |
| { |
| public: |
| CIntNodeDeleteReq( int req_nid |
| , int req_pid |
| , Verifier_t req_verifier |
| , int pnid ); |
| virtual ~CIntNodeDeleteReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| |
| int req_nid_; |
| int req_pid_; |
| Verifier_t req_verifier_; |
| int pnid_; |
| }; |
| |
| class CIntDownReq: public CInternalReq |
| { |
| public: |
| CIntDownReq( int pnid ); |
| virtual ~CIntDownReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| |
| int pnid_; |
| }; |
| |
| class CIntSoftNodeDownReq: public CInternalReq |
| { |
| public: |
| CIntSoftNodeDownReq( int pnid ); |
| virtual ~CIntSoftNodeDownReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| |
| int pnid_; |
| }; |
| |
| class CIntSoftNodeUpReq: public CInternalReq |
| { |
| public: |
| CIntSoftNodeUpReq( int pnid ); |
| virtual ~CIntSoftNodeUpReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| |
| int pnid_; |
| }; |
| |
| class CIntUpReq: public CInternalReq |
| { |
| public: |
| CIntUpReq( int pnid, char *node_name, int merge_lead ); |
| virtual ~CIntUpReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| |
| string nodeName_; |
| int mergeLead_; |
| int pnid_; |
| }; |
| |
| class CIntActivateSpareReq: public CInternalReq |
| { |
| public: |
| CIntActivateSpareReq(CNode *spareNode, CNode *downNode, bool checkHealth); |
| virtual ~CIntActivateSpareReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| |
| CNode *spareNode_; |
| CNode *downNode_; |
| bool checkHealth_; |
| }; |
| |
| class CIntReviveReq: public CInternalReq |
| { |
| public: |
| CIntReviveReq(); |
| virtual ~CIntReviveReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| }; |
| |
| class CIntSnapshotReq: public CInternalReq |
| { |
| public: |
| CIntSnapshotReq(unsigned long long seqNum); |
| virtual ~CIntSnapshotReq(); |
| |
| void performRequest(); |
| |
| void setSeqNum(unsigned long long seqNum) { seqNum_ = seqNum; } |
| unsigned long long getSeqNum() { return seqNum_; } |
| |
| private: |
| void populateRequestString( void ); |
| |
| unsigned long long seqNum_; |
| }; |
| |
| class CQuiesceReq: public CInternalReq |
| { |
| public: |
| CQuiesceReq(); |
| virtual ~CQuiesceReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| }; |
| |
| class CPostQuiesceReq: public CInternalReq |
| { |
| public: |
| CPostQuiesceReq(); |
| virtual ~CPostQuiesceReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| }; |
| |
| #ifndef NAMESERVER_PROCESS |
| class CIntCreatePrimitiveReq: public CInternalReq |
| { |
| public: |
| CIntCreatePrimitiveReq( int pnid ); |
| virtual ~CIntCreatePrimitiveReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| |
| int pnid_; |
| }; |
| #endif |
| |
| #ifndef NAMESERVER_PROCESS |
| class CIntTmReadyReq: public CInternalReq |
| { |
| public: |
| CIntTmReadyReq( int nid ); |
| virtual ~CIntTmReadyReq(); |
| |
| void performRequest(); |
| |
| private: |
| void populateRequestString( void ); |
| |
| int nid_; |
| }; |
| #endif |
| |
| class CReqQueue |
| { |
| private: |
| int eyecatcher_; // Debuggging aid -- leave as first |
| // member variable of the class |
| public: |
| CReqQueue(); |
| virtual ~CReqQueue(); |
| |
| void enqueueReq(CExternalReq::reqQueueMsg_t msgType, |
| int nid, int pid, int sockFd, |
| struct message_def *msg); |
| void enqueueCloneReq( struct clone_def *cloneDef ); |
| #ifndef NAMESERVER_PROCESS |
| void enqueueDeviceReq( char *ldevName ); |
| #endif |
| #ifndef NAMESERVER_PROCESS |
| void enqueueExitReq( struct exit_def *exitDef ); |
| #else |
| void enqueueExitNsReq( struct exit_ns_def *exitDef ); |
| #endif |
| #ifdef NAMESERVER_PROCESS |
| void enqueueDeleteReq( struct delete_def *deleteDef ); |
| #endif |
| #ifndef NAMESERVER_PROCESS |
| void enqueueIoDataReq( ioData_t *ioData ); |
| void enqueueKillReq( struct kill_def *killDef ); |
| void enqueueNewProcReq( struct process_def *procDef ); |
| #endif |
| #ifdef NAMESERVER_PROCESS |
| void enqueueNewProcNsReq( struct process_def *procDef ); |
| #endif |
| #ifndef NAMESERVER_PROCESS |
| void enqueueNotifyReq( struct notify_def *notifyDef ); |
| void enqueueOpenReq( struct open_def *openDef ); |
| #endif |
| void enqueueProcInitReq( struct process_init_def *procInitDef ); |
| void enqueueSetReq( struct set_def *setDef ); |
| #ifndef NAMESERVER_PROCESS |
| void enqueueStdInReq( struct stdin_req_def *stdin_req ); |
| #endif |
| void enqueueUniqStrReq( struct uniqstr_def *uniqStrDef ); |
| #ifndef NAMESERVER_PROCESS |
| void enqueueChildDeathReq ( pid_t pid ); |
| void enqueueAttachedDeathReq ( pid_t pid ); |
| #endif |
| void enqueueNameServerAddReq( int req_nid |
| , int req_pid |
| , Verifier_t req_verifier |
| , char *node_name ); |
| void enqueueNameServerDeleteReq( int req_nid |
| , int req_pid |
| , Verifier_t req_verifier |
| , char *node_name ); |
| void enqueueNodeAddReq( int req_nid |
| , int req_pid |
| , Verifier_t req_verifier |
| , char *node_name |
| , int firstCore |
| , int lastCore |
| , int processors |
| , int roles ); |
| void enqueueNodeDeleteReq( int req_nid |
| , int req_pid |
| , Verifier_t req_verifier |
| , int pnid ); |
| void enqueueDownReq( int pnid ); |
| void enqueueNodeNameReq( int req_nid |
| , int req_pid |
| , Verifier_t req_verifier |
| , char *current_name |
| , char *new_name); |
| void enqueueSoftNodeDownReq( int pnid ); |
| void enqueueSoftNodeUpReq( int pnid ); |
| void enqueueShutdownReq( int level ); |
| void enqueueActivateSpareReq( CNode *spareNode, CNode *downNode, bool checkHealth=false ); |
| void enqueueUpReq( int pnid, char *node_name, int merge_lead ); |
| void enqueueReviveReq(); |
| void enqueueSnapshotReq(unsigned long long seqnum); |
| bool addToReqReviveQueue(CInternalReq *request); |
| void processReviveRequests(unsigned long long seqNum); |
| #ifndef NAMESERVER_PROCESS |
| void enqueueCreatePrimitiveReq( int pnid ); |
| #endif |
| void enqueueQuiesceReq(); |
| void enqueuePostQuiesceReq(); |
| #ifndef NAMESERVER_PROCESS |
| void enqueueTmReadyReq( int nid ); |
| #endif |
| CRequest *getRequest(); |
| void finishRequest(CRequest *request); |
| void nudgeWorker(); |
| |
| void stats(); |
| |
| static void timeDiff ( struct timespec t1, struct timespec t2, |
| struct timespec &tDiff ); |
| bool responsive(struct timespec &curTime); |
| |
| int getExecTimeMax() { return execTimeMax_; } |
| |
| enum { REQ_MAX_PERFORM = 1, // Max seconds expected for request execution |
| REQ_MAX_TOTAL = 3, // Max seconds expected for request lifetime |
| REQ_MAX_DEFER = 10, // Max seconds request can be deferred |
| REQ_MAX_RESPONSIVE = 10 }; // Max seconds before request is "stuck" |
| |
| static const char *svcReqType[]; |
| static const char *intReqType[]; |
| |
| private: |
| CExternalReq * prepExternalReq(CExternalReq::reqQueueMsg_t msgType, |
| int nid, int pid, int sockFd, |
| struct message_def *msg); |
| void enqueueReq(CInternalReq *req, bool reviveOper = false); |
| |
| bool busyExclusive_; // true if an exclusive request in progress, |
| // false otherwise. |
| int busyWorkers_; // Count of worker threads currently |
| // working on requests. |
| int syncDependentRequests_; |
| |
| // statistics |
| int maxQueueSize_; |
| int maxBusyWorkers_; |
| long numRequests_; |
| |
| struct timespec mostRecentStart_; |
| |
| // locks |
| CLock workerStatusLock_; |
| |
| CLock reqQueueLock_; |
| |
| typedef list<CRequest *> reqList_t; |
| reqList_t reqQueue_; |
| reqList_t reqDeferred_; |
| |
| CLock reqReviveQueueLock_; |
| |
| typedef list<CInternalReq *> reqListInt_t; |
| reqListInt_t reqReviveQueue_; |
| |
| static const bool reqConcurrent[]; |
| int execTimeMax_; // maximum time allowed for the current request |
| |
| }; |
| |
| #endif |
| |
| /* CRequest eyecatcher_ assignments: |
| |
| CInternalReq: |
| |
| RQIA CIntAttachedDeathReq |
| RQIB CPostQuiesceReq |
| RQIC CIntChildDeathReq |
| RQID CIntDeviceReq |
| RQIE CIntExitReq |
| RQIF CIntUniqStrReq |
| RQIG CIntSnapshotReq |
| RQIH CIntShutdownReq |
| RQII CIntProcInitReq |
| RQIJ CIntNodeAddReq |
| RqIK CIntIoDataReq |
| RQIK CIntKillReq |
| RQIL CIntCloneProcReq |
| RQIM CIntActivateSpareReq |
| RQIN CIntNewProcReq |
| RQIO CIntOpenReq |
| RQIP CIntDownReq |
| RQIQ CIntUpReq |
| RQIR CIntReviveReq |
| RQIS CIntSetReq |
| RqIS CIntStdInReq |
| RQIT CIntNodeDeleteReq |
| RQIU CQuiesceReq |
| RQIV CIntTmReadyReq |
| RQIW CIntCreatePrimitiveReq |
| RQIX CIntSoftNodeDownReq |
| RQIY CIntSoftNodeUpReq |
| RQIZ CIntNodeNameReq |
| RqIA CIntNameServerAddReq |
| RqIB CIntNameServerDeleteReq |
| |
| CExternalReq: |
| RQEA CExtAttachStartupReq |
| RqEA CExtDelProcessNsReq |
| RQEB CExtDumpReq |
| RQEC CExtEventReq |
| RQED CExtExitReq |
| RQEE CExtGetReq |
| RQEF CExtKillReq |
| RQEG CExtMonStatsReq |
| RQEH CExtMountReq |
| RQEI CExtNewProcReq |
| RqEB CExtNewProcessNsReq |
| RQEJ CExtNodeDownReq |
| RqEJ CExtNodeDownNsReq |
| RQEK CExtNodeInfoReq |
| RQEK CExtPNodeInfoReq |
| RQEL CExtNodeUpReq |
| RQEM CExtNotifyReq |
| RqEC CExtNameServerAddReq |
| RqED CExtNameServerDeleteReq |
| RqEE CExtNameServerStartReq |
| RqEF CExtNameServerStopReq |
| RqEG CExtNameServerNsStartReq |
| RqEH CExtNameServerNsStopReq |
| RQEN CExtOpenReq |
| RQEO CExtProcInfoReq |
| RQEP CExtProcInfoContReq |
| RQEQ CExtSetReq |
| RQER CExtShutdownReq |
| RqER CExtShutdownNsReq |
| RQES CExtStartupReq |
| RQET CExtTmLeaderReq |
| RQEV CExtTmSyncReq |
| RQEW CExtZoneInfoReq |
| RQEX CExtNodeAddReq |
| RQEY CExtNodeDeleteReq |
| RQEZ CExtNodeNameReq |
| RQE_ CExtNullReq |
| |
| */ |
