bool VideoDecoderThread::work()
{
if (m_pDecoder->isEOF(SS_VIDEO)) {
if (!m_pDecoder->getVideoInfo().m_bHasAudio) {
m_pDecoder->seek(0);
} else {
// TODO: Replace this with waitForMessage()
msleep(10);
}
} else {
ScopeTimer timer(DecoderProfilingZone);
vdpau_render_state* pRenderState = 0;
FrameAvailableCode frameAvailable;
vector<BitmapPtr> pBmps;
bool usesVDPAU = m_pDecoder->getVideoInfo().m_bUsesVDPAU;
if (usesVDPAU) {
#ifdef AVG_ENABLE_VDPAU
frameAvailable = m_pDecoder->renderToVDPAU(&pRenderState);
#else
frameAvailable = FA_NEW_FRAME; // Never executed - silences compiler warning.
#endif
} else {
IntPoint size = m_pDecoder->getSize();
IntPoint halfSize(size.x/2, size.y/2);
PixelFormat pf = m_pDecoder->getPixelFormat();
if (pixelFormatIsPlanar(pf)) {
pBmps.push_back(getBmp(m_pBmpQ, size, I8));
pBmps.push_back(getBmp(m_pHalfBmpQ, halfSize, I8));
pBmps.push_back(getBmp(m_pHalfBmpQ, halfSize, I8));
if (pf == YCbCrA420p) {
pBmps.push_back(getBmp(m_pBmpQ, size, I8));
}
} else {
pBmps.push_back(getBmp(m_pBmpQ, size, pf));
}
frameAvailable = m_pDecoder->renderToBmps(pBmps, -1);
}
if (m_pDecoder->isEOF(SS_VIDEO)) {
VideoMsgPtr pMsg(new VideoMsg());
pMsg->setEOF();
m_MsgQ.push(pMsg);
} else {
ScopeTimer timer(PushMsgProfilingZone);
AVG_ASSERT(frameAvailable == FA_NEW_FRAME);
VideoMsgPtr pMsg(new VideoMsg());
if (usesVDPAU) {
pMsg->setVDPAUFrame(pRenderState, m_pDecoder->getCurTime(SS_VIDEO));
} else {
pMsg->setFrame(pBmps, m_pDecoder->getCurTime(SS_VIDEO));
}
m_MsgQ.push(pMsg);
msleep(0);
}
ThreadProfiler::get()->reset();
}
return true;
}
test_ll_t *run()
{
test_ll_t *newTest = NULL, *lastTest = NULL;
if (cleanArgs.flags & CLD_FLG_FSLIST) {
char *filespec = cleanArgs.device;
char *aFilespec = NULL;
FILE *file = NULL;
if ((aFilespec = (char *)ALLOC(80)) == NULL) {
pMsg(ERR, &cleanArgs,
"Could not allocate memory to read file");
return newTest;
}
file = fopen(filespec, "r");
if (file == NULL) {
pMsg(ERR,
&cleanArgs,
"%s is not a regular file, could not be opened for reading, or was not found.",
filespec);
FREE(aFilespec);
return newTest;
}
while (!feof(file)) {
memset(aFilespec, 0, 80);
fscanf(file, "%79s", aFilespec);
if (aFilespec[0] != 0) { /* if we read something useful */
lastTest = newTest;
newTest = getNewTest(lastTest);
if (newTest != lastTest) {
memset(newTest->args->device, 0,
DEV_NAME_LEN);
strncpy(newTest->args->device,
aFilespec, strlen(aFilespec));
createChild(threadedMain, newTest);
} else {
newTest = lastTest;
break;
}
}
}
fclose(file);
FREE(aFilespec);
} else {
newTest = getNewTest(newTest);
if (newTest != NULL) {
createChild(threadedMain, newTest);
}
}
return newTest;
}
void ChatHistory::insertHistoryLine(const QString& originator, const QDateTime timestamp, const QString& message)
{
c4_Row row;
c4_StringProp pOriginator("originator");
c4_StringProp pMsg("msg");
pOriginator(row) = originator.toUtf8().constData();
pMsg(row) = message.toUtf8().constData();
view->Add(row);
}
///////////////////////////////////////////////////////////////////////////////
///@author Costin Grigorescu
///@brief Forward DAO to EntryPoint
///@param [in] p_nDataFieldDescriptor - Data field descriptor
///@param [in] p_pPayload - DAO message
///@param [in] p_nPayloadLength - DAO message len
///@retval 0 - failed to send
///@retval 1 - success
///////////////////////////////////////////////////////////////////////////////
void CRplRootApp::AddDAORelayEncap(MgmtProtocol::CMgmtPMessage::MsgDAORelayData::DataFieldDescriptorType p_nDataFieldDescriptor,
const uint8_t* p_pPayload,
uint16_t p_nPayloadLength){
MgmtProtocol::CMgmtPMessage::Ptr pMsg(new MgmtProtocol::CMgmtPMessage);
//init header
pMsg->m_Header.SetMsgType(MgmtProtocol::CMgmtPMessage::DAO_RELAY);
pMsg->m_Header.m_u32SeqNo = m_pMgmtClientLink->m_oSeqNoGenerator.GetNextMsgId ( );
MgmtProtocol::CMgmtPMessage::MsgDAORelayData oMsgDAORelayData;
// set far id
oMsgDAORelayData.m_pu8_FAR_ID = GetFarId();
// set data field descriptor
oMsgDAORelayData.m_u8_DataFieldDescriptor = p_nDataFieldDescriptor;
// set DIO MOP
oMsgDAORelayData.m_u8_DIO_MOP = GET_MOP( &g_oRplInstance.m_oRplConfig );
// set lifetime_unit
oMsgDAORelayData.m_u16_DIOLifetimeUnit = m_stCfg.m_oMapConfig.m_oRplProfile.m_nDefRouteLifetimeUnit;
// set DAO message
oMsgDAORelayData.m_pu8_DAOData = p_pPayload;
oMsgDAORelayData.m_u32_DAODataLen = p_nPayloadLength;
NLOG_INFO( "Encap+ DAO_RELAY: far=%s, dfd=%d, dao_len=%d",
GetHex( oMsgDAORelayData.m_pu8_FAR_ID, oMsgDAORelayData.m_st_u8_FAR_ID_Len ),
oMsgDAORelayData.m_u8_DataFieldDescriptor,
oMsgDAORelayData.m_u32_DAODataLen );
NLOG_DBG( "\tdao=%s", GetHex( oMsgDAORelayData.m_pu8_DAOData, oMsgDAORelayData.m_u32_DAODataLen ) );
pMsg->SetData(&oMsgDAORelayData);
m_shpoCnsDaoMsg->OptionAddEncap(pMsg.get());
}
int do_dump(child_args_t * args)
{
ssize_t NumBytes = 0;
OFF_T TargetLBA, TotalBytes = 0;
char *buff;
fd_t fd;
if ((buff = (char *)ALLOC(args->htrsiz * BLK_SIZE)) == NULL) {
fprintf(stderr, "Can't allocate buffer\n");
return (-1);
}
memset(buff, 0, args->htrsiz * BLK_SIZE);
fd = Open(args->device, args->flags | CLD_FLG_R);
if (INVALID_FD(fd)) {
pMsg(ERR, args, "could not open %s.\n", args->device);
pMsg(ERR, args, "%s: Error = %u\n", args->device,
GETLASTERROR());
return (-1);
}
TargetLBA = Seek(fd, args->start_lba * BLK_SIZE);
if (TargetLBA != (args->start_lba * (OFF_T) BLK_SIZE)) {
pMsg(ERR, args, "Could not seek to start position.\n");
CLOSE(fd);
return (-1);
}
do {
NumBytes = Read(fd, buff, args->htrsiz * BLK_SIZE);
if ((NumBytes > args->htrsiz * BLK_SIZE) || (NumBytes < 0)) {
pMsg(ERR, args, "Failure reading %s\n", args->device);
pMsg(ERR, args, "Last Error was %lu\n", GETLASTERROR());
break;
}
dump_data(stdout, buff, NumBytes, 16, 0, FMT_STR);
TotalBytes += (OFF_T) NumBytes;
} while ((TotalBytes < (args->htrsiz * BLK_SIZE)) && (NumBytes > 0));
FREE(buff);
CLOSE(fd);
return 0;
}
int generateElementsN(element ***e){
int i,j,k;
for(i=0;i<nTotalElements;i++){
if(setParamsN((*e)[i])<0){
pMsg("erro ao gerar os elementos");
}
}
return(0);
}
void sendPingMsg(ffnet::udp_point * point, const ffnet::udp_endpoint & tp)
{
boost::shared_ptr<PingPong::Ping> pMsg(new PingPong::Ping());
pMsg->set_msg("ping from client");
pMsg->set_id(1);
ffnet::send_message(point, tp, pMsg);
std::cout<<"send a message, service running..."<<std::endl;
}
int main(int argc, char **argv)
{
extern time_t global_start_time;
extern unsigned long glb_flags; /* global flags GLB_FLG_xxx */
int i;
#ifdef WINDOWS
WORD wVersionRequested;
WSADATA wsaData;
int err;
wVersionRequested = MAKEWORD(2, 2);
err = WSAStartup(wVersionRequested, &wsaData);
if (err != 0) {
pMsg(WARN, &cleanArgs,
"Windows setup of Winsock failed, can't retrieve host name, continuing");
}
#endif
setup_sig_mask();
memset(hostname, 0, HOSTNAME_SIZE);
gethostname(hostname, HOSTNAME_SIZE);
setbuf(stdout, NULL);
glb_flags = 0;
global_start_time = time(NULL);
strncpy(cleanArgs.device, "No filespec", strlen("No filespec"));
cleanArgs.stop_lba = -1;
cleanArgs.stop_blk = -1;
cleanArgs.ioTimeout = DEFAULT_IO_TIMEOUT;
cleanArgs.flags |= CLD_FLG_ALLDIE;
cleanArgs.flags |= CLD_FLG_ERR_REREAD;
cleanArgs.flags |= CLD_FLG_LBA_SYNC;
for (i = 1; i < argc - 1; i++) {
strncat(cleanArgs.argstr, argv[i],
(MAX_ARG_LEN - 1) - strlen(cleanArgs.argstr));
strncat(cleanArgs.argstr, " ",
(MAX_ARG_LEN - 1) - strlen(cleanArgs.argstr));
}
if (fill_cld_args(argc, argv, &cleanArgs) < 0)
exit(1);
cleanUp(run());
#ifdef WINDOWS
WSACleanup();
#endif
return 0;
}
void sendPingMsg(ffnet::EndpointPtr_t tp)
{
boost::shared_ptr<PingPong::Ping> pMsg(new PingPong::Ping());
pMsg->set_msg("ping from client");
pMsg->set_id(1);
ffnet::NetNervure::send(pMsg, tp);
std::cout<<"service running..."<<std::endl;
}
void createChild(void *function, test_ll_t *test) {
hThread_t hTmpThread;
hTmpThread = spawnThread(function, test);
if (ISTHREADVALID(hTmpThread)) {
test->hThread = hTmpThread;
} else {
pMsg(ERR, test->args, "%d : Could not create child thread...\n", GETLASTERROR());
exit(GETLASTERROR());
}
}
void VideoDecoderThread::handleEOF()
{
bool bGotPicture = m_pFrameDecoder->decodeLastFrame(m_pFrame);
if (bGotPicture) {
sendFrame(m_pFrame);
} else {
m_bProcessingLastFrames = false;
VideoMsgPtr pMsg(new VideoMsg());
pMsg->setEOF();
pushMsg(pMsg);
}
}
void VideoDemuxerThread::close()
{
map<int, VideoMsgQueuePtr>::iterator it;
for (it = m_PacketQs.begin(); it != m_PacketQs.end(); it++) {
VideoMsgQueuePtr pPacketQ = it->second;
clearQueue(pPacketQ);
VideoMsgPtr pMsg(new VideoMsg);
pMsg->setClosed();
pPacketQ->push(pMsg);
m_PacketQEOFMap[it->first] = false;
}
stop();
}
/*
* This function will create children for us based on the action specified
* during the call. if we cannot create a child, we fail and exit with
* errno as the exit status.
*/
void CreateTestChild(void *function, test_ll_t *test)
{
thread_struct_t *pNewThread;
hThread_t hTmpThread;
hTmpThread = spawnThread(function, test);
if (ISTHREADVALID(hTmpThread)) {
if ((pNewThread = (thread_struct_t *) ALLOC(sizeof(thread_struct_t))) == NULL) {
pMsg(ERR, test->args, "%d : Could not allocate memory for child thread...\n", GETLASTERROR());
exit(GETLASTERROR());
}
test->env->kids++;
memset(pNewThread, 0, sizeof(thread_struct_t));
pNewThread->next = test->env->pThreads;
test->env->pThreads = pNewThread;
test->env->pThreads->hThread = hTmpThread;
} else {
pMsg(ERR, test->args, "%d : Could not create all child threads.\n", GETLASTERROR());
pMsg(INFO, test->args, "Total Number of Threads created was %u\n", test->env->kids);
exit(GETLASTERROR());
}
}
void normalize_percs(child_args_t *args)
{
int i, j;
if ((args->flags & CLD_FLG_R) && !(args->flags & CLD_FLG_W)) {
if ((args->flags & CLD_FLG_DUTY) && (args->rperc < 100)) {
pMsg(WARN, args, "Read specified w/o write, ignoring -D, forcing read only...\n");
}
args->rperc = 100;
args->wperc = 0;
} else if ((args->flags & CLD_FLG_W) && !(args->flags & CLD_FLG_R)) {
if ((args->flags & CLD_FLG_DUTY) && (args->wperc < 100)) {
pMsg(WARN, args, "Write specified w/o read, ignoring -D, forcing write only...\n");
}
args->rperc = 0;
args->wperc = 100;
} else { /* must be reading and writing */
if (args->rperc == 0 && args->wperc == 0) {
args->rperc = 50;
args->wperc = 50;
} else if (args->rperc == 0) {
args->rperc = 100 - args->wperc;
} else if (args->wperc == 0) {
args->wperc = 100 - args->rperc;
}
}
if (args->rperc + args->wperc != 100) {
pMsg(INFO, args, "Balancing percentage between reads and writes\n");
if ((args->flags & CLD_FLG_R) && (args->flags & CLD_FLG_W)) {
i = 100 - (args->rperc + args->wperc);
j = i / 2;
args->wperc += j;
args->rperc += (i - j);
}
}
}
void CRplRootApp::AddTopologyNotificationEncap(MgmtProtocol::CMgmtPMessage::EventType p_enumEventType,
const uint8_t* p_pu8NodeId, const TIpv6Prefix& p_rNodePrefix, MgmtProtocol::DeviceType p_enumNodeType,
const uint8_t* p_pu8ParentId, MgmtProtocol::DeviceType p_enumParentType)
{
if (!m_stCfg.m_nTopologyMgmtMsgsEnabled)
{ return;
}
MgmtProtocol::CMgmtPMessage::Ptr pMsg(new MgmtProtocol::CMgmtPMessage);
//init header
pMsg->m_Header.SetMsgType(MgmtProtocol::CMgmtPMessage::TOPOLOGY_NOTIFICATION);
pMsg->m_Header.m_u32SeqNo = m_pMgmtClientLink->m_oSeqNoGenerator.GetNextMsgId ( );
//init data
MgmtProtocol::CMgmtPMessage::MsgTopologyNotifData oData;
memset(&oData, 0, sizeof(oData));
oData.m_u8NotifType = (uint8_t) p_enumEventType;
if (p_pu8NodeId)
{
memcpy (oData.m_au8DeviceId,p_pu8NodeId,IPv6_HOST_ID_LEN);
}
else
{
memcpy(oData.m_au8DeviceId,
p_rNodePrefix.m_oIPv6Addr.m_pucBytes + PrefixLenInBytes(p_rNodePrefix.m_u8PrefixLen) - IPV6_DEVID_LEN,
IPV6_DEVID_LEN);
}
oData.m_u8DeviceType = p_enumNodeType;
memcpy (oData.m_au8DeviceAddrIPv6, p_rNodePrefix.m_oIPv6Addr.m_pucBytes, PrefixLenInBytes(p_rNodePrefix.m_u8PrefixLen));
oData.m_u8ParentType = p_enumParentType;
memcpy(oData.m_au8ParentId, p_pu8ParentId, IPv6_HOST_ID_LEN);
oData.m_u32Timestamp = (uint32_t)(time(NULL));
NLOG_INFO("Encap+ %s", oData.GetPrintable());
oData.HtoN();
pMsg->SetData((uint8_t*)(&oData), sizeof(oData));
m_shpoCnsTopoNotifMsg->OptionAddEncap(pMsg.get());
}
/*
* Creates a new test structure and adds it to the list of
* test structures already available. Allocate all memory
* needed by the new test.
*
* Returns the newly created test structure
*/
test_ll_t *getNewTest(test_ll_t * testList)
{
test_ll_t *pNewTest;
if ((pNewTest = (test_ll_t *) ALLOC(sizeof(test_ll_t))) == NULL) {
pMsg(ERR, &cleanArgs,
"%d : Could not allocate memory for new test.\n",
GETLASTERROR());
return NULL;
}
memset(pNewTest, 0, sizeof(test_ll_t));
if ((pNewTest->args =
(child_args_t *) ALLOC(sizeof(child_args_t))) == NULL) {
pMsg(ERR, &cleanArgs,
"%d : Could not allocate memory for new test.\n",
GETLASTERROR());
FREE(pNewTest);
return NULL;
}
if ((pNewTest->env = (test_env_t *) ALLOC(sizeof(test_env_t))) == NULL) {
pMsg(ERR, &cleanArgs,
"%d : Could not allocate memory for new test.\n",
GETLASTERROR());
FREE(pNewTest->args);
FREE(pNewTest);
return NULL;
}
memcpy(pNewTest->args, &cleanArgs, sizeof(child_args_t));
memcpy(pNewTest->env, &cleanEnv, sizeof(test_env_t));
pNewTest->next = testList;
testList = pNewTest;
return pNewTest;
}
void VideoDemuxerThread::seek(int seqNum, float destTime)
{
map<int, VideoMsgQueuePtr>::iterator it;
m_pDemuxer->seek(destTime);
for (it = m_PacketQs.begin(); it != m_PacketQs.end(); it++) {
VideoMsgQueuePtr pPacketQ = it->second;
clearQueue(pPacketQ);
// send SEEK_DONE
VideoMsgPtr pMsg(new VideoMsg);
pMsg->setSeekDone(seqNum, destTime);
pPacketQ->push(pMsg);
m_PacketQEOFMap[it->first] = false;
}
m_bEOF = false;
}
LRESULT CChatWnd::OnChatMessage(WPARAM /*wParam*/, LPARAM lParam)
{
CAutoPtr< CChatMessage > pMsg( (CChatMessage*)lParam );
if ( pMsg->m_hBitmap )
{
CChatWnd::AddBitmap( pMsg->m_hBitmap );
}
switch ( pMsg->m_bType )
{
case cmtProfile:
Open();
SetAlert();
CChatWnd::AddLogin( pMsg->m_sFrom );
break;
case cmtError:
SetAlert();
case cmtStatus:
case cmtInfo:
CChatWnd::OnStatusMessage( (int)pMsg->m_bType - (int)cmtStatus, pMsg->m_sMessage );
break;
case cmtMessage:
CChatWnd::OnMessage( false, GetChatID(), false, pMsg->m_sFrom, MyProfile.GetNick(), pMsg->m_sMessage );
break;
case cmtAction:
CChatWnd::OnMessage( false, GetChatID(), false, pMsg->m_sFrom, MyProfile.GetNick(), pMsg->m_sMessage );
break;
case cmtCaption:
m_sCaption = _T(" : ") + pMsg->m_sMessage;
break;
default:
;
}
SetWindowText( GetCaption() + m_sCaption );
return 0;
}
FFFunctionThreadPool::~FFFunctionThreadPool()
{
while (m_iParaFuncNum)
{
utl::sleep<1>();
}
utl::MsgPort<FFMsg> port;
port.setMsgSwitch(m_oSwitch);
FFMsgPtr pMsg(new FFMsg(FFMsg::mt_terminate, 0));
port.sendMsg(pMsg->getType(), pMsg);
for (int i = 0; i < m_iPoolSize; ++i)
m_pWorkers[i].terminate();
m_oTP.wait();
#ifdef _DEBUG
log_tpool("FFFunctionThreadPool", "~FFFunctionThreadPool(), workers terminated!");
#endif
delete[] m_pWorkers;
}
void VideoDecoderThread::seek(float destTime)
{
while (!m_MsgQ.empty()) {
m_MsgQ.pop(false);
}
float VideoFrameTime = -1;
float AudioFrameTime = -1;
m_pDecoder->seek(destTime);
if (m_pDecoder->getVideoInfo().m_bHasVideo) {
VideoFrameTime = m_pDecoder->getCurTime(SS_VIDEO);
}
if (m_pDecoder->getVideoInfo().m_bHasAudio) {
AudioFrameTime = m_pDecoder->getCurTime(SS_AUDIO);
}
VideoMsgPtr pMsg(new VideoMsg());
pMsg->setSeekDone(VideoFrameTime, AudioFrameTime);
m_MsgQ.push(pMsg);
}
bool VideoDemuxerThread::work()
{
if (m_bEOF) {
waitForCommand();
} else {
map<int, VideoMsgQueuePtr>::iterator it;
int shortestQ = -1;
int shortestLength = INT_MAX;
for (it = m_PacketQs.begin(); it != m_PacketQs.end(); it++) {
if (it->second->size() < shortestLength &&
it->second->size() < it->second->getMaxSize() &&
!m_PacketQEOFMap[it->first])
{
shortestLength = it->second->size();
shortestQ = it->first;
}
}
if (shortestQ < 0) {
// All queues are at their max capacity. Take a nap and try again later.
// Note that we can't wait on the queue. If decoding is paused, the queues can
// remain full indefinitely and commands from the application (seek() and
// close() must still be processed.
msleep(10);
return true;
}
AVPacket * pPacket = m_pDemuxer->getPacket(shortestQ);
VideoMsgPtr pMsg(new VideoMsg);
if (pPacket == 0) {
onStreamEOF(shortestQ);
pMsg->setEOF();
} else {
pMsg->setPacket(pPacket);
}
m_PacketQs[shortestQ]->push(pMsg);
msleep(0);
}
return true;
}
void PeerNode::HandleConnectionBroken()
{
m_bConnected = false;
ConnectionManagerPtr pConnMgr = ConnectionManager::GetConnectionManager();
if( pConnMgr == NULL ) return;
PeerPtr pPeer = pConnMgr->GetPeer();
if( pPeer == NULL ) return;
// send the message to the main peer
MessageQueuePtr pMsgQ = pPeer->GetMessageQueue();
if( pMsgQ == NULL ) return;
WMessagePtr pWMsg(new WMessage);
pWMsg->SetPeerId(this->m_peerId);
pWMsg->SetSysMsg(CONNECTION_FAILURE_ON_PEER);
MessagePtr pMsg(new Message);
pMsg->m_conn = this->m_pConn;
pMsg->m_mesgType = INTERNAL;
pWMsg->SetMsg(pMsg);
pMsgQ->PutMessage(pWMsg);
}
void VideoDecoderThread::sendFrame(AVFrame* pFrame)
{
VideoMsgPtr pMsg(new VideoMsg());
vector<BitmapPtr> pBmps;
if (pixelFormatIsPlanar(m_PF)) {
ScopeTimer timer(CopyImageProfilingZone);
IntPoint halfSize(m_Size.x/2, m_Size.y/2);
pBmps.push_back(getBmp(m_pBmpQ, m_Size, I8));
pBmps.push_back(getBmp(m_pHalfBmpQ, halfSize, I8));
pBmps.push_back(getBmp(m_pHalfBmpQ, halfSize, I8));
if (m_PF == YCbCrA420p) {
pBmps.push_back(getBmp(m_pBmpQ, m_Size, I8));
}
for (unsigned i = 0; i < pBmps.size(); ++i) {
m_pFrameDecoder->copyPlaneToBmp(pBmps[i], pFrame->data[i],
pFrame->linesize[i]);
}
} else {
pBmps.push_back(getBmp(m_pBmpQ, m_Size, m_PF));
m_pFrameDecoder->convertFrameToBmp(pFrame, pBmps[0]);
}
pMsg->setFrame(pBmps, m_pFrameDecoder->getCurTime());
pushMsg(pMsg);
}
/*
* checks validity of data after parsing
* args and make assumtions. returns 0 on
* success and -1 on failure.
*/
int check_conclusions(child_args_t *args)
{
extern unsigned long glb_flags;
struct stat stat_buf;
int rv;
if ((args->flags & CLD_FLG_DUTY) && ((args->flags & CLD_FLG_LINEAR) || (args->flags & CLD_FLG_NTRLVD))) {
pMsg(WARN, args, "Duty cycle testing is supported for random (-pR) tests only.\n");
return(-1);
}
if ((args->flags & CLD_FLG_BLK_RNG) && (args->flags & CLD_FLG_RTRSIZ)) {
pMsg(WARN, args, "Can't have unfixed block sizes and specify seek range in terms of blocks.\n");
return(-1);
}
if ((args->vsiz < 0) || (args->ltrsiz < 1) || (args->htrsiz < 1)) {
pMsg(WARN, args, "Bounds exceeded for transfer size and/or volume size.\n");
pMsg(WARN, args, MAXTRSIZ, (args->htrsiz*BLK_SIZE),args->vsiz);
return(-1);
}
if (args->htrsiz < args->ltrsiz) {
pMsg(ERR, args, "Min transfer size, %lu, greater then Max transfer size, %lu.\n", args->ltrsiz, args->htrsiz);
return(-1);
}
if (args->vsiz < (args->stop_lba-args->start_lba+1)) {
pMsg(ERR, args, "Volume stop block/lba exceeds volume size.\n");
return(-1);
}
if (args->vsiz < args->htrsiz) {
pMsg(WARN, args, VSIZETS, args->vsiz, args->htrsiz);
return(-1);
}
if ((args->flags & CLD_FLG_TMD) == 0 && (args->seeks <= 0)) {
pMsg(WARN,args, TSEEK, args->seeks);
return(-1);
}
if ((args->flags & CLD_FLG_SKS) && (args->t_kids > args->seeks)) {
pMsg(WARN, args, "Can't have more children then max number of seeks, use -K/-L to adjust.\n");
return(-1);
}
if ((args->start_blk > args->vsiz) && !(args->flags & (CLD_FLG_BLK_RNG|CLD_FLG_LBA_RNG))) {
pMsg(WARN, args, STBGTTLBA, args->start_blk, (args->vsiz / args->htrsiz));
return(-1);
}
if ((args->stop_blk > args->vsiz) && !(args->flags & (CLD_FLG_BLK_RNG|CLD_FLG_LBA_RNG))) {
pMsg(WARN, args, SBGTTLBA, args->stop_blk, (args->vsiz / args->htrsiz));
return(-1);
}
if ((args->start_lba > args->vsiz) && !(args->flags & (CLD_FLG_BLK_RNG|CLD_FLG_LBA_RNG))) {
pMsg(WARN, args, STLBAGTLBA, args->start_lba, args->vsiz);
return(-1);
}
if ((args->stop_lba > args->vsiz) && !(args->flags & (CLD_FLG_BLK_RNG|CLD_FLG_LBA_RNG))) {
pMsg(WARN, args, SLBAGTLBA, args->stop_lba, args->vsiz);
return(-1);
}
if (args->start_blk > args->stop_blk) {
pMsg(WARN, args, SBRSB, args->stop_blk, args->start_blk);
return(-1);
}
if (args->start_lba > args->stop_lba) {
pMsg(ERR, args, SLBARSLBA, args->stop_lba, args->start_lba);
return(-1);
}
if ((args->flags & CLD_FLG_LBA_RNG) && (args->flags & CLD_FLG_BLK_RNG)) {
pMsg(ERR, args, "Can't specify range in both block and LBA, use -s or -S.\n");
return(-1);
}
/* use stat to get file properties, and test then agains specified -I */
rv = stat(args->device, &stat_buf);
if (0 == rv) { /* no error on call to stat, compare against -I option */
/* files are usually file type */
if ((args->flags & CLD_FLG_FILE) && !IS_FILE(stat_buf.st_mode)) {
pMsg(ERR, args, "Can't open non-file filespec with file device type, -If.\n");
return(-1);
}
/* block devices, are usually block type */
if ((args->flags & CLD_FLG_BLK) && !IS_BLK(stat_buf.st_mode)) {
pMsg(ERR, args, "Can't open non-block filespec with block device type, -Ib.\n");
return(-1);
}
#ifndef WINDOWS
/* raw devices, are usually character type */
if ((args->flags & CLD_FLG_RAW) && !S_ISCHR(stat_buf.st_mode)) {
pMsg(ERR, args, "Can't open non-raw filespec with raw device type, -Ir.\n");
return(-1);
}
#else
if (args->flags & CLD_FLG_RAW) {
pMsg(ERR, args, "RAW IO type not supported in Windows, use direct IO instead.\n");
return(-1);
}
#endif
#ifdef _DEBUG
} else {
PDBG1(DBUG, args, "Can't get status on %s, assuming a new file, errno = %d\n", args->device, GETLASTERROR());
#endif
}
if ((args->hbeat > 0) && (args->flags & CLD_FLG_TMD) && (args->hbeat > args->run_time)) {
pMsg(ERR, args, "Heartbeat should be at least equal to runtime, use -h/-T to adjust.\n");
return(-1);
}
if ((args->hbeat > 0) && !(args->flags & CLD_FLG_PRFTYPS)) {
pMsg(ERR, args, "At least one performance option, -P, must be specified when using -h.\n");
return(-1);
}
if ((args->flags & CLD_FLG_W) && !(args->flags & CLD_FLG_R) && (args->flags & CLD_FLG_CMPR)) {
pMsg(ERR, args, "Write only, ignoring option -E.\n");
}
if ((args->flags & CLD_FLG_TMD) && (args->flags & CLD_FLG_SKS)) {
pMsg(ERR, args, "Can't specify both -L and -T they are mutually exclusive.\n");
return(-1);
}
if (((args->flags & CLD_FLG_R) && !(args->flags & CLD_FLG_W)) && (args->flags & CLD_FLG_ERR_MARK)) {
pMsg(ERR, args, "Can't specify mark on error, -Am, in read only mode.\n");
return(-1);
}
if (!(args->flags & CLD_FLG_ALLDIE) && (args->flags & CLD_FLG_ERR_MARK)) {
pMsg(ERR, args, "Can't specify mark on error, -Am, when continue on error is set.\n");
return(-1);
}
if ((glb_flags & GLB_FLG_KILL) && !(args->flags & CLD_FLG_ALLDIE)) {
pMsg(ERR, args, "Can't specify global kill, -Ag, when continue on error is set, -Ac.\n");
return(-1);
}
if ((args->flags & CLD_FLG_LINEAR) && !(args->flags & CLD_FLG_NTRLVD) && (args->flags & CLD_FLG_TMD)) {
pMsg(ERR, args, "Linear read / write test can not be timed.\n");
return(-1);
}
if ((args->flags & CLD_FLG_CMPR) && (args->cmp_lng > (args->ltrsiz*BLK_SIZE))) {
pMsg(ERR, args, "Compare length, %lu, is greater then transfer size, %lu\n", args->cmp_lng, args->ltrsiz*BLK_SIZE);
return(-1);
}
if ((args->flags & CLD_FLG_OFFSET) && (args->offset > args->stop_lba)) {
pMsg(ERR, args, LBAOFFGSLBA, args->offset, args->stop_lba);
return(-1);
}
if ((args->flags & CLD_FLG_OFFSET) && ((args->offset+args->ltrsiz-1) > args->stop_lba)) {
pMsg(ERR, args, LBAOTSGSLBA, args->offset, args->ltrsiz, args->stop_lba);
return(-1);
}
return 0;
}
int make_assumptions(child_args_t *args)
{
char TmpStr[80];
struct stat stat_buf;
int rv;
if (!(args->flags & CLD_FLG_IOTYPS)) {
/* use stat to get file properties, and use to set -I */
rv = stat(args->device, &stat_buf);
if (0 == rv) {
if (IS_FILE(stat_buf.st_mode)) {
strncat(args->argstr, "(-I f) ", (MAX_ARG_LEN-1)-strlen(args->argstr));
args->flags |= CLD_FLG_FILE;
} else if (IS_BLK(stat_buf.st_mode)) {
strncat(args->argstr, "(-I b) ", (MAX_ARG_LEN-1)-strlen(args->argstr));
args->flags |= CLD_FLG_BLK;
#ifndef WINDOWS
} else if (S_ISCHR(stat_buf.st_mode)) {
strncat(args->argstr, "(-I r) ", (MAX_ARG_LEN-1)-strlen(args->argstr));
args->flags |= CLD_FLG_RAW;
#endif
}
} else {
pMsg(WARN, args, "Can't get status on %s, defaulting to file, errno = %d\n", args->device, GETLASTERROR());
strncat(args->argstr, "(-I f) ", (MAX_ARG_LEN-1)-strlen(args->argstr));
args->flags |= CLD_FLG_FILE;
}
}
if ((args->flags & CLD_FLG_WFSYNC) && (0 == args->sync_interval)) {
pMsg(INFO, args, "Sync interval set to zero, assuming interval of 1.\n");
args->sync_interval = 1;
}
if (args->ltrsiz <= 0) {
sprintf(TmpStr, "(-B %d) ", TRSIZ*BLK_SIZE);
strncat(args->argstr, TmpStr, (MAX_ARG_LEN-1)-strlen(args->argstr));
args->ltrsiz=TRSIZ;
args->htrsiz=TRSIZ;
}
if (args->flags & CLD_FLG_LBA_RNG) {
args->start_blk = args->start_lba / args->htrsiz;
if (!(args->stop_lba < 0))
args->stop_blk = args->stop_lba / args->htrsiz;
}
if (args->flags & CLD_FLG_BLK_RNG) {
args->start_lba = args->start_blk * args->htrsiz;
if (!(args->stop_blk < 0))
args->stop_lba = (args->stop_blk * args->htrsiz) + (args->htrsiz - 1);
}
/* if vsiz is still not set, try and get it from the file */
if ((args->vsiz <=0) && (args->flags & CLD_FLG_FILE)) {
if (0 != get_file_size(args->device)) { /* file size retrieved */
args->vsiz=get_file_size(args->device);
}
}
/* if vsiz is still not set, try and get it from the device */
if ((args->vsiz <= 0) && !(args->flags & CLD_FLG_FILE)) {
args->vsiz=get_vsiz(args->device);
}
/* if vsiz is still not set, set based on given range */
if ((args->vsiz <=0) && (args->flags & (CLD_FLG_LBA_RNG|CLD_FLG_BLK_RNG))) {
if (!(args->stop_lba < 0))
args->vsiz=args->stop_lba+1;
else
args->vsiz=args->start_lba+1;
}
/* if vsiz is still not set, then set it to the default size */
if (args->vsiz <= 0) {
args->vsiz=VSIZ;
}
if (!(args->flags & CLD_FLG_VSIZ)) {
sprintf(TmpStr, N_ASSUME, args->vsiz);
strncat(args->argstr, TmpStr, (MAX_ARG_LEN-1)-strlen(args->argstr));
}
if (args->stop_lba == -1) {
args->stop_lba=args->vsiz-1;
}
if (args->stop_blk == -1) {
args->stop_blk=(args->stop_lba / (OFF_T) args->htrsiz);
}
if (args->t_kids == 0) {
sprintf(TmpStr, "(-K %d) ", KIDS);
strncat(args->argstr, TmpStr, (MAX_ARG_LEN-1)-strlen(args->argstr));
args->t_kids=KIDS;
}
if ((args->flags & (CLD_FLG_W|CLD_FLG_R)) == 0) {
if (args->flags & CLD_FLG_DUTY) { /* no read/write but duty cycle specified */
if (args->rperc > 0) {
args->flags |= CLD_FLG_R;
strncat(args->argstr, "(-r) ", (MAX_ARG_LEN-1)-strlen(args->argstr));
}
if (args->wperc > 0) {
args->flags |= CLD_FLG_W;
strncat(args->argstr, "(-w) ", (MAX_ARG_LEN-1)-strlen(args->argstr));
}
} else {
strncat(args->argstr, "(-r) ", (MAX_ARG_LEN-1)-strlen(args->argstr));
args->flags |= CLD_FLG_R;
}
}
if (!(args->flags & CLD_FLG_PTYPS)) {
strncat(args->argstr, "(-c) ", (MAX_ARG_LEN-1)-strlen(args->argstr));
args->flags |= CLD_FLG_CPTYPE;
}
if (!(args->flags & CLD_FLG_SKTYPS)) {
strncat(args->argstr, "(-p R) ", (MAX_ARG_LEN-1)-strlen(args->argstr));
args->flags |= CLD_FLG_RANDOM;
}
if (!(args->flags & CLD_FLG_SKS)) {
if (args->start_blk == args->stop_blk) { /* diskcache test, w/ no seek count set */
args->seeks = SEEKS;
} else if (args->flags & (CLD_FLG_BLK_RNG|CLD_FLG_LBA_RNG)) { /* range set, w/ no seek count */
args->seeks = args->stop_blk - args->start_blk + 1;
} else {
/* if vsiz is available, calculated seeks are in terms of the largest transfer size */
args->seeks = (args->vsiz > 0) ? (args->vsiz / args->htrsiz) : SEEKS;
}
if ((args->flags & CLD_FLG_LINEAR) && (args->flags & CLD_FLG_R) && (args->flags & CLD_FLG_W)) {
args->seeks *= 2;
}
if (!(args->flags & CLD_FLG_TMD)) {
sprintf(TmpStr, L_ASSUME, args->seeks);
strncat(args->argstr, TmpStr, (MAX_ARG_LEN-1)-strlen(args->argstr));
}
}
if (!(args->flags & (CLD_FLG_SKS|CLD_FLG_TMD)) || ((args->flags & CLD_FLG_CYC) && !(args->flags & (CLD_FLG_SKS|CLD_FLG_TMD)))) {
args->flags |= CLD_FLG_SKS;
}
if (args->flags & (CLD_FLG_LINEAR)) {
if (!(args->flags & (CLD_FLG_LUNU|CLD_FLG_LUND))) {
strncat(args->argstr, "(-p u) ", (MAX_ARG_LEN-1)-strlen(args->argstr));
args->flags |= CLD_FLG_LUNU;
}
}
normalize_percs(args);
if (!(args->flags & CLD_FLG_DUTY) && (args->flags & CLD_FLG_RANDOM) && !(args->flags & CLD_FLG_NTRLVD)) {
sprintf(TmpStr, "(-D %d:%d) ", args->rperc, args->wperc);
strncat(args->argstr, TmpStr, (MAX_ARG_LEN-1)-strlen(args->argstr));
args->flags |= CLD_FLG_DUTY;
}
if ((args->delayTimeMin == 0) && (args->delayTimeMax == 0) && (args->ioTimeout == DEFAULT_IO_TIMEOUT)) {
strncat(args->argstr, "(-t 0:2m) ", (MAX_ARG_LEN-1)-strlen(args->argstr));
}
if (!(args->flags & CLD_FLG_OFFSET)) {
strncat(args->argstr, "(-o 0) ", (MAX_ARG_LEN-1)-strlen(args->argstr));
}
return 0;
}
int fill_cld_args(int argc, char **argv, child_args_t *args)
{
extern char *optarg;
extern int optind;
extern unsigned long glb_flags;
signed char c;
char *leftovers;
while ((c = getopt(argc, argv, "?a:A:B:cC:dD:E:f:Fh:I:K:L:m:M:nN:o:p:P:qQrR:s:S:t:T:wvV:z")) != -1) {
switch(c) {
case ':' :
pMsg(WARN, args, "Missing argument for perameter.\n");
usage();
return(-1);
case 'V' :
#ifdef _DEBUG
if (optarg == NULL) {
pMsg(WARN, args, "-%c option requires an argument.\n", c);
exit(1);
}
if (!isdigit(optarg[0])) {
pMsg(WARN, args, "-%c argument is non numeric.\n", c);
exit(1);
}
gbl_dbg_lvl = atoi(optarg);
#else
pMsg(ERR, args, "Debug code not compiled in, recompile with _DEBUG directive.\n", c);
exit(1);
#endif
break;
case 'd' :
glb_flags |= GLB_FLG_QUIET;
args->flags |= CLD_FLG_DUMP;
break;
case 'a' :
if (optarg == NULL) {
pMsg(WARN, args, "-%c option requires an argument.\n", c);
return(-1);
}
if (!isdigit(optarg[0])) {
pMsg(WARN, args, "-%c arguments is non numeric.\n", c);
return(-1);
}
args->seed = (unsigned int) strtol(optarg, NULL, 0);
break;
case 'A' :
if (optarg == NULL) {
pMsg(WARN, args, "-%c option requires an argument.\n", c);
exit(1);
}
if (strchr(optarg,'g')) {
glb_flags |= GLB_FLG_KILL;
}
if (strchr(optarg,'c')) {
args->flags &= ~CLD_FLG_ALLDIE;
}
if (strchr(optarg,'m')) {
args->flags |= CLD_FLG_ERR_MARK;
}
if (strchr(optarg,'r')) {
args->flags &= ~CLD_FLG_ERR_REREAD;
}
if (strchr(optarg,'s')) {
args->flags &= ~CLD_FLG_LBA_SYNC;
}
if (strchr(optarg,'S')) {
args->flags |= CLD_FLG_IO_SERIAL;
}
if (strchr(optarg,'w')) {
args->flags |= CLD_FLG_WRITE_ONCE;
}
if (strchr(optarg,'W')) {
args->flags |= CLD_FLG_UNIQ_WRT;
}
if (strchr(optarg,'t')) {
args->flags |= CLD_FLG_TMO_ERROR;
}
break;
case 'q' :
glb_flags |= GLB_FLG_QUIET;
break;
case 'Q' :
glb_flags |= GLB_FLG_SUPRESS;
break;
case 'v' :
pMsg(INFO, args, "Version %s\n", VER_STR);
exit(0);
case 'p' :
if (optarg == NULL) {
pMsg(WARN, args, "-%c option requires an argument.\n", c);
return(-1);
}
if (args->flags & (CLD_FLG_LINEAR|CLD_FLG_RANDOM)) {
pMsg(WARN, args, "Only one seek type, -p, can be specified.\n");
return(-1);
}
/* seek pattern type */
if (strchr(optarg,'L'))
args->flags |= CLD_FLG_LINEAR;
else if (strchr(optarg,'l'))
args->flags |= (CLD_FLG_LINEAR|CLD_FLG_NTRLVD);
else if (strchr(optarg,'R'))
args->flags |= CLD_FLG_RANDOM;
else if (strchr(optarg,'r'))
args->flags |= (CLD_FLG_RANDOM|CLD_FLG_NTRLVD);
else {
pMsg(WARN, args, "Unknown Seek pattern\n");
usage();
return(-1);
}
if (strchr(optarg,'U') || strchr(optarg,'u'))
if ((args->flags & (CLD_FLG_LINEAR)) &&
!(args->flags & CLD_FLG_LUND))
args->flags |= CLD_FLG_LUNU;
if (strchr(optarg,'D') || strchr(optarg,'d'))
if ((args->flags & (CLD_FLG_LINEAR)) &&
!(args->flags & CLD_FLG_LUNU))
args->flags |= CLD_FLG_LUND;
break;
case 'B' :
if (!isdigit(optarg[0])) {
pMsg(WARN, args, "-%c arguments is non numeric.\n", c);
return(-1);
}
if (strchr(optarg,':') != NULL) { /* we are given a range of transfer sizes */
args->flags |= CLD_FLG_RTRSIZ;
args->ltrsiz = strtoul(optarg, &leftovers, 10);
if (leftovers == strchr(leftovers,'k')) { /* first value had a 'k' */
args->ltrsiz *= 2;
leftovers++;
} else if (leftovers == strchr(leftovers, 'm')) { /* first value had a 'm' */
args->ltrsiz *= (2 * 1024);
leftovers++;
} else {
if (args->ltrsiz > 256)
args->ltrsiz /= BLK_SIZE;
}
if (!isdigit(leftovers[1])) {
pMsg(WARN, args, "-%c arguments is non numeric.\n", c);
return(-1);
}
args->htrsiz = atol((char *)strchr(leftovers,':')+1);
if ((strchr(leftovers,'k')) != NULL) {/* second value had a 'k' */
args->htrsiz *= 2;
} else if ((strchr(leftovers,'m')) != NULL) { /* second value had a 'm' */
args->htrsiz *= (2 * 1024);
} else {
if (args->htrsiz > 256)
args->htrsiz /= BLK_SIZE;
}
} else { /* only a single value given for transfer size */
args->ltrsiz = atoi(optarg);
if (strchr(optarg,'k')) {
args->ltrsiz *= 2;
} else if (strchr(optarg,'m')) {
args->ltrsiz *= (2 * 1024);
} else {
if (args->ltrsiz > 256)
args->ltrsiz /= BLK_SIZE;
}
args->htrsiz = args->ltrsiz;
}
#ifdef _DEBUG
PDBG5(DBUG, args, "Parsed Transfer size: %ld\n", args->htrsiz);
#endif
break;
case 'c' :
if (args->flags & CLD_FLG_PTYPS) {
pMsg(WARN, args, "Please specify only one pattern type\n");
usage();
return(-1);
}
args->flags |= CLD_FLG_CPTYPE;
break;
case 'n' :
if (args->flags & CLD_FLG_PTYPS) {
pMsg(WARN, args, "Please specify only one pattern type\n");
usage();
return(-1);
}
args->flags |= CLD_FLG_LPTYPE;
break;
case 'f' :
if (optarg == NULL) {
pMsg(WARN, args, "-%c option requires an argument.\n", c);
return(-1);
}
if (args->flags & CLD_FLG_PTYPS) {
pMsg(WARN, args, "Please specify only one pattern type\n");
usage();
return(-1);
}
args->pattern = my_strtofft(optarg);
args->flags |= CLD_FLG_FPTYPE;
break;
case 'F' :
/* the filespec is a list of filespecs in a file */
args->flags |= CLD_FLG_FSLIST;
break;
case 'z' :
if (args->flags & CLD_FLG_PTYPS) {
pMsg(WARN, args, "Please specify only one pattern type\n");
usage();
return(-1);
}
args->flags |= CLD_FLG_RPTYPE;
break;
case 'h' :
if (optarg == NULL) {
pMsg(WARN, args, "-%c option requires an argument.\n", c);
return(-1);
}
if (!isdigit(optarg[0])) {
pMsg(WARN, args, "-%c arguments is non numeric.\n", c);
usage();
return(-1);
}
args->flags |= CLD_FLG_HBEAT;
args->hbeat = atoi(optarg);
if (strchr(optarg,'m')) { /* multiply by sec */
args->hbeat *= 60;
} else if (strchr(optarg,'h')) { /* multiply sec*min */
args->hbeat *= (time_t) (60*60);
} else if (strchr(optarg,'d')) { /* multiply by sec*min*hours */
args->hbeat *= (time_t) (60*60*24);
}
break;
case 'D' :
if (optarg == NULL) {
pMsg(WARN, args, "-%c option requires an argument.\n", c);
return(-1);
}
if (!isdigit(optarg[0])) {
pMsg(WARN, args, "-%c arguments is non numeric.\n", c);
usage();
return(-1);
}
args->rperc = atoi(optarg);
args->wperc = atoi((char *)(strchr(optarg,':')+1));
args->flags |= CLD_FLG_DUTY;
break;
case 'r' :
args->flags |= CLD_FLG_R;
break;
case 'w' :
args->flags |= CLD_FLG_W;
break;
case 'o' :
if (optarg == NULL) {
pMsg(WARN, args, "-%c option requires an argument.\n", c);
return(-1);
}
args->offset = atol(optarg);
args->flags |= CLD_FLG_OFFSET;
break;
case 'R' :
if (optarg == NULL) {
pMsg(WARN, args, "-%c option requires an argument.\n", c);
return(-1);
}
if (strchr(optarg,':') != NULL) { /* we are given a retry delay */
args->retries = strtol(optarg, &leftovers, 10);
args->retry_delay = (time_t) atol((char *)strchr(leftovers,':')+1);
} else { /* only a retry count given */
args->retries = atoi(optarg);
}
break;
case 'M' :
if (optarg == NULL) {
pMsg(WARN, args, "-%c option requires an argument.\n", c);
return(-1);
}
args->flags |= CLD_FLG_ALT_MARK;
args->alt_mark = my_strtofft(optarg);
break;
case 'm' :
args->flags |= CLD_FLG_MBLK;
if (optarg == NULL) {
pMsg(WARN, args, "-%c option requires an argument.\n", c);
return(-1);
}
if (strchr(optarg,'l')) { /* returns NULL if char is not found */
args->flags |= CLD_FLG_MRK_LBA;
}
if (strchr(optarg,'p')) {
args->flags |= CLD_FLG_MRK_PASS;
}
if (strchr(optarg,'t')) {
args->flags |= CLD_FLG_MRK_TIME;
}
if (strchr(optarg,'s')) {
args->flags |= CLD_FLG_MRK_SEED;
}
if (strchr(optarg,'h')) {
args->flags |= CLD_FLG_MRK_HOST;
}
if (strchr(optarg,'f')) {
args->flags |= CLD_FLG_MRK_TARGET;
}
if (strchr(optarg,'a')) {
args->flags |= CLD_FLG_MRK_ALL;
}
if (!strchr(optarg,'l') &&
!strchr(optarg,'p') &&
!strchr(optarg,'t') &&
!strchr(optarg,'s') &&
!strchr(optarg,'h') &&
!strchr(optarg,'f') &&
!strchr(optarg,'a')) {
pMsg(WARN, args, "Unknown header mark option\n");
return(-1);
}
break;
case 'E' :
if (optarg == NULL) {
pMsg(WARN, args, "-%c option requires an argument.\n", c);
return(-1);
}
if (!isdigit(optarg[0])) {
pMsg(WARN, args, "-%c arguments are non numeric.\n", c);
usage();
return(-1);
}
args->flags |= CLD_FLG_CMPR;
args->cmp_lng = strtol(optarg,NULL,0);
if (strchr(optarg,'k')) { /* multiply by 2^10 */
args->cmp_lng <<= 10;
} else if (strchr(optarg,'K')) { /* multiply 10^3 */
args->cmp_lng *= 1000;
} else if (strchr(optarg,'m')) { /* multiply by 2^20 */
args->cmp_lng <<= 20;
} else if (strchr(optarg,'M')) { /* multiply by 10^6 */
args->cmp_lng *= 1000000;
}
break;
case 'N' :
if (optarg == NULL) {
pMsg(WARN, args, "-%c option requires an argument.\n", c);
return(-1);
}
if (!isdigit(optarg[0])) {
pMsg(WARN, args, "-%c arguments are non numeric.\n", c);
return(-1);
}
args->flags |= CLD_FLG_VSIZ;
args->vsiz = my_strtofft(optarg);
if (strchr(optarg,'k')) { /* multiply by 2^10 */
args->vsiz <<= 10;
} else if (strchr(optarg,'K')) { /* multiply 10^3 */
args->vsiz *= 1000;
} else if (strchr(optarg,'m')) { /* multiply by 2^20 */
args->vsiz <<= 20;
} else if (strchr(optarg,'M')) { /* multiply by 10^6 */
args->vsiz *= 1000000;
} else if (strchr(optarg,'g')) { /* multiply by 2^30 */
args->vsiz <<= 30;
} else if (strchr(optarg,'G')) { /* multiply by 10^9 */
args->vsiz *= 1000000000;
}
break;
case 'I' :
if (optarg == NULL) {
pMsg(WARN, args, "-%c option requires an argument.\n", c);
return(-1);
}
if (strchr(optarg,'R') || strchr(optarg,'r')) {
if (!(args->flags & CLD_FLG_BLK) &&
!(args->flags & CLD_FLG_FILE)) {
args->flags |= CLD_FLG_RAW;
} else {
pMsg(WARN, args, "Can only specify one IO type\n");
return(-1);
}
}
if (strchr(optarg,'B') || strchr(optarg,'b')) {
if (!(args->flags & CLD_FLG_RAW) &&
!(args->flags & CLD_FLG_FILE)) {
args->flags |= CLD_FLG_BLK;
} else {
pMsg(WARN, args, "Can only specify one IO type\n");
return(-1);
}
}
if (strchr(optarg,'F') || strchr(optarg,'f')) {
if (!(args->flags & CLD_FLG_RAW) &&
!(args->flags & CLD_FLG_BLK)) {
args->flags |= CLD_FLG_FILE;
} else {
pMsg(WARN, args, "Can only specify one IO type\n");
return(-1);
}
}
if (strchr(optarg,'D') || strchr(optarg,'d')) {
args->flags |= CLD_FLG_DIRECT;
}
if (strchr(optarg,'s')) {
args->sync_interval = strtoul((char *)strchr(optarg,'s')+1, NULL, 10);
#ifdef _DEBUG
PDBG3(DBUG, args, "Parsed sync interval: %ld\n", args->sync_interval);
#endif
if ((args->flags & CLD_FLG_DIRECT)) {
pMsg(ERR, args, "Can't specify sync with Direct IO\n");
return(-1);
}
args->flags |= CLD_FLG_WFSYNC;
}
break;
case 't' :
if (optarg == NULL) {
pMsg(WARN, args, "-%c option requires an argument.\n", c);
return(-1);
}
if (strchr(optarg,':') != NULL) { /* we are given a option for delay & timeout */
args->delayTimeMin = strtoul(optarg, &leftovers, 10);
/* check to see if we have one or more then one ':' */
if ((char *)strchr(optarg,':') == (char *)strrchr(optarg,':')) {
/* only one ':', assume no random delayTime, and ioTimeout */
args->delayTimeMax = args->delayTimeMin;
args->ioTimeout = (time_t) atol((char *)strchr(leftovers,':')+1);
} else {
/* more then one ':', assume random delayTime, and ioTimeout */
args->delayTimeMax = strtoul(leftovers+1, &leftovers, 10);
args->ioTimeout = (time_t) atol((char *)strchr(leftovers,':')+1);
}
if (strchr(leftovers,'m')) { /* multiply by sec */
args->ioTimeout *= 60;
} else if (strchr(leftovers,'h')) { /* multiply sec*min */
args->ioTimeout *= (time_t) (60*60);
} else if (strchr(leftovers,'d')) { /* multiply by sec*min*hours */
args->ioTimeout *= (time_t) (60*60*24);
}
} else {
args->delayTimeMin = strtoul(optarg, (char **)NULL, 10);
args->delayTimeMax = args->delayTimeMin;
}
break;
case 'T' :
if (optarg == NULL) {
pMsg(WARN, args, "-%c option requires an argument.\n", c);
return(-1);
}
args->run_time = atoi(optarg);
args->flags |= CLD_FLG_TMD;
if (strchr(optarg,'m')) { /* multiply by sec */
args->run_time *= 60;
} else if (strchr(optarg,'h')) { /* multiply sec*min */
args->run_time *= (time_t) (60*60);
} else if (strchr(optarg,'d')) { /* multiply by sec*min*hours */
args->run_time *= (time_t) (60*60*24);
}
break;
case 'L' :
if (optarg == NULL) {
pMsg(WARN, args, "-%c option requires an argument.\n", c);
return(-1);
}
args->seeks = atoi(optarg);
args->flags |= CLD_FLG_SKS;
if (strchr(optarg,'k')) { /* multiply by 2^10 */
args->seeks <<= 10;
} else if (strchr(optarg,'K')) { /* multiply 10^3 */
args->seeks *= 1000;
} else if (strchr(optarg,'m')) { /* multiply by 2^20 */
args->seeks <<= 20;
} else if (strchr(optarg,'M')) { /* multiply by 10^6 */
args->seeks *= 1000000;
} else if (strchr(optarg,'g')) { /* multiply by 2^30 */
args->seeks <<= 30;
} else if (strchr(optarg,'G')) { /* multiply by 10^9 */
args->seeks *= 1000000000;
}
break;
case 'C' :
if (optarg == NULL) {
pMsg(WARN, args, "-%c option requires an argument.\n", c);
return(-1);
}
if (!isdigit(optarg[0])) {
pMsg(WARN, args, "-%c arguments is non numeric.\n", c);
usage();
return(-1);
}
args->flags |= CLD_FLG_CYC;
args->cycles = atol(optarg);
break;
case 'K' :
if (optarg == NULL) {
pMsg(WARN, args, "-%c option requires an argument.\n", c);
return(-1);
}
if (!isdigit(optarg[0])) {
pMsg(WARN, args, "-%c arguments is non numeric.\n", c);
usage();
return(-1);
}
if (atoi(optarg) > MAX_THREADS) {
pMsg(WARN, args, "%u exceeds max of %u threads.\n", atoi(optarg), MAX_THREADS);
return(-1);
}
args->t_kids = atoi(optarg);
break;
case 'P' :
if (optarg == NULL) {
pMsg(WARN, args, "-%c option requires an argument.\n", c);
return(-1);
}
if (strchr(optarg,'X')) { /* returns NULL if char is not found */
args->flags |= CLD_FLG_XFERS;
}
if (strchr(optarg,'T')) {
args->flags |= CLD_FLG_TPUTS;
}
if (strchr(optarg,'P')) {
glb_flags |= GLB_FLG_PERFP;
}
if (strchr(optarg,'R')) {
args->flags |= CLD_FLG_RUNT;
}
if (strchr(optarg,'C')) {
args->flags |= CLD_FLG_PCYC;
}
if (strchr(optarg,'A')) {
args->flags |= CLD_FLG_PRFTYPS;
}
if (!strchr(optarg,'P') &&
!strchr(optarg,'A') &&
!strchr(optarg,'X') &&
!strchr(optarg,'R') &&
!strchr(optarg,'C') &&
!strchr(optarg,'T')) {
pMsg(WARN, args, "Unknown performance option\n");
return(-1);
}
break;
case 'S' :
if (!isdigit((int)optarg[0])) {
pMsg(WARN, args, "-%c arguments is non numeric.\n", c);
return(-1);
}
args->flags |= CLD_FLG_BLK_RNG;
if (strchr(optarg,':') != NULL) { /* we are given a range */
args->start_blk = (OFF_T) strtoul(optarg, &leftovers, 0);
if (leftovers == strchr(leftovers,'k')) { /* multiply by 2^10 */
args->start_blk <<= 10;
leftovers++; /* at the ':' */
} else if (leftovers == strchr(leftovers,'K')) { /* multiply 10^3 */
args->start_blk *= 1000;
leftovers++; /* at the ':' */
} else if (leftovers == strchr(leftovers,'m')) { /* multiply by 2^20 */
args->start_blk <<= 20;
leftovers++; /* at the ':' */
} else if (leftovers == strchr(leftovers,'M')) { /* multiply by 10^6 */
args->start_blk *= 1000000;
leftovers++; /* at the ':' */
} else if (leftovers == strchr(leftovers,'g')) { /* multiply by 2^30 */
args->start_blk <<= 30;
leftovers++; /* at the ':' */
} else if (leftovers == strchr(leftovers,'G')) { /* multiply by 10^9 */
args->start_blk *= 1000000000;
leftovers++; /* at the ':' */
}
leftovers++; /* should be at the next value */
if (!isdigit((int) leftovers[0])) {
pMsg(WARN, args, "-%c arguments is non numeric.\n", c);
return(-1);
}
args->stop_blk = (OFF_T) strtoul(leftovers, &leftovers, 0);
if (leftovers == strchr(leftovers,'k')) { /* multiply by 2^10 */
args->stop_blk <<= 10;
} else if (leftovers == strchr(leftovers,'K')) { /* multiply 10^3 */
args->stop_blk *= 1000;
} else if (leftovers == strchr(leftovers,'m')) { /* multiply by 2^20 */
args->stop_blk <<= 20;
} else if (leftovers == strchr(leftovers,'M')) { /* multiply by 10^6 */
args->stop_blk *= 1000000;
} else if (leftovers == strchr(leftovers,'g')) { /* multiply by 2^30 */
args->stop_blk <<= 30;
} else if (leftovers == strchr(leftovers,'G')) { /* multiply by 10^9 */
args->stop_blk *= 1000000000;
}
} else { /* only a single value given */
args->start_blk = (OFF_T) strtoul(optarg, &leftovers, 0);
if (leftovers == strchr(leftovers,'k')) { /* multiply by 2^10 */
args->start_blk <<= 10;
} else if (leftovers == strchr(leftovers,'K')) { /* multiply 10^3 */
args->start_blk *= 1000;
} else if (leftovers == strchr(leftovers,'m')) { /* multiply by 2^20 */
args->start_blk <<= 20;
} else if (leftovers == strchr(leftovers,'M')) { /* multiply by 10^6 */
args->start_blk *= 1000000;
} else if (leftovers == strchr(leftovers,'g')) { /* multiply by 2^30 */
args->start_blk <<= 30;
} else if (leftovers == strchr(leftovers,'G')) { /* multiply by 10^9 */
args->start_blk *= 1000000000;
}
}
break;
case 's' :
if (!isdigit((int)optarg[0])) {
pMsg(WARN, args, "-%c argument is non numeric.\n", c);
return(-1);
}
args->flags |= CLD_FLG_LBA_RNG;
if (strchr(optarg,':') != NULL) { /* we are given a range */
args->start_lba = (OFF_T) strtoul(optarg, &leftovers, 0);
if (leftovers == strchr(leftovers,'k')) { /* multiply by 2^10 */
args->start_lba <<= 10;
leftovers++; /* at the ':' */
} else if (leftovers == strchr(leftovers,'K')) { /* multiply 10^3 */
args->start_lba *= 1000;
leftovers++; /* at the ':' */
} else if (leftovers == strchr(leftovers,'m')) { /* multiply by 2^20 */
args->start_lba <<= 20;
leftovers++; /* at the ':' */
} else if (leftovers == strchr(leftovers,'M')) { /* multiply by 10^6 */
args->start_lba *= 1000000;
leftovers++; /* at the ':' */
} else if (leftovers == strchr(leftovers,'g')) { /* multiply by 2^30 */
args->start_lba <<= 30;
leftovers++; /* at the ':' */
} else if (leftovers == strchr(leftovers,'G')) { /* multiply by 10^9 */
args->start_lba *= 1000000000;
leftovers++; /* at the ':' */
}
leftovers++; /* should be at the next value */
if (!isdigit((int) leftovers[0])) {
pMsg(WARN, args, "-%c second argument is non numeric.\n", c);
return(-1);
}
args->stop_lba = (OFF_T) strtoul(leftovers, &leftovers, 0);
if (leftovers == strchr(leftovers,'k')) { /* multiply by 2^10 */
args->stop_lba <<= 10;
} else if (leftovers == strchr(leftovers,'K')) { /* multiply 10^3 */
args->stop_lba *= 1000;
} else if (leftovers == strchr(leftovers,'m')) { /* multiply by 2^20 */
args->stop_lba <<= 20;
} else if (leftovers == strchr(leftovers,'M')) { /* multiply by 10^6 */
args->stop_lba *= 1000000;
} else if (leftovers == strchr(leftovers,'g')) { /* multiply by 2^30 */
args->stop_lba <<= 30;
} else if (leftovers == strchr(leftovers,'G')) { /* multiply by 10^9 */
args->stop_lba *= 1000000000;
}
} else { /* only a single value given */
args->start_lba = (OFF_T) strtoul(optarg, &leftovers, 0);
if (leftovers == strchr(leftovers,'k')) { /* multiply by 2^10 */
args->start_lba <<= 10;
} else if (leftovers == strchr(leftovers,'K')) { /* multiply 10^3 */
args->start_lba *= 1000;
} else if (leftovers == strchr(leftovers,'m')) { /* multiply by 2^20 */
args->start_lba <<= 20;
} else if (leftovers == strchr(leftovers,'M')) { /* multiply by 10^6 */
args->start_lba *= 1000000;
} else if (leftovers == strchr(leftovers,'g')) { /* multiply by 2^30 */
args->start_lba <<= 30;
} else if (leftovers == strchr(leftovers,'G')) { /* multiply by 10^9 */
args->start_lba *= 1000000000;
}
}
break;
case '?' :
default :
usage();
return(-1);
}
}
if (argv[optind] == NULL) {
pMsg(WARN, args, "Unspecified target.\n");
return(-1);
}
strncpy(args->device, argv[optind], (DEV_NAME_LEN-1));
return 0;
}
void AudioDecoderThread::pushEOF()
{
VideoMsgPtr pMsg(new VideoMsg());
pMsg->setEOF();
m_MsgQ.push(pMsg);
}
void AudioDecoderThread::pushSeekDone(float time, int seqNum)
{
VideoMsgPtr pMsg(new VideoMsg());
pMsg->setSeekDone(seqNum, time);
m_MsgQ.push(pMsg);
}
void AudioDecoderThread::pushAudioMsg(AudioBufferPtr pBuffer, float time)
{
VideoMsgPtr pMsg(new VideoMsg());
pMsg->setAudio(pBuffer, time);
m_MsgQ.push(pMsg);
}
void *ChildTimer(void *vtest)
#endif
{
#ifndef WINDOWS
test_ll_t *test = (test_ll_t *) vtest;
#endif
time_t ioTimeoutCount = 0;
time_t total_time = 0;
OFF_T cur_total_io_count = 0;
OFF_T last_total_io_count = 0;
OFF_T tmp_io_count = 0;
time_t run_time = 0;
lvl_t msg_level = WARN;
child_args_t *args = test->args;
test_env_t *env = test->env;
extern int signal_action;
extern unsigned short glb_run;
#ifdef _DEBUG
PDBG3(DBUG, args, "In timer %lu, %d\n", time(NULL), env->bContinue);
#endif
do {
Sleep(1000);
run_time++;
#ifdef _DEBUG
PDBG3(DBUG, args, "Continue timing %lu, %lu, %d\n", time(NULL),
run_time, env->bContinue);
#endif
if (args->flags & CLD_FLG_W) {
if ((args->flags & CLD_FLG_LINEAR)
&& !(args->flags & CLD_FLG_NTRLVD)) {
if (TST_OPER(args->test_state) == WRITER) {
env->hbeat_stats.wtime++;
}
} else {
env->hbeat_stats.wtime++;
}
}
if (args->flags & CLD_FLG_R) {
if ((args->flags & CLD_FLG_LINEAR)
&& !(args->flags & CLD_FLG_NTRLVD)) {
if (TST_OPER(args->test_state) == READER) {
env->hbeat_stats.rtime++;
}
} else {
env->hbeat_stats.rtime++;
}
}
/*
* Check to see if we have made any IO progress in the last interval,
* if not incremment the ioTimeout timer, otherwise, clear it
*/
cur_total_io_count = env->global_stats.wcount
+ env->cycle_stats.wcount
+ env->hbeat_stats.wcount
+ env->global_stats.rcount
+ env->cycle_stats.rcount + env->hbeat_stats.rcount;
if (cur_total_io_count == 0) {
tmp_io_count = 1;
} else {
tmp_io_count = cur_total_io_count;
}
total_time = env->global_stats.rtime
+ env->cycle_stats.rtime
+ env->hbeat_stats.rtime
+ env->global_stats.wtime
+ env->cycle_stats.wtime + env->hbeat_stats.wtime;
#ifdef _DEBUG
PDBG3(DBUG, args, "average number of seconds per IO: %0.8lf\n",
((double)(total_time) / (double)(tmp_io_count)));
#endif
if (cur_total_io_count == last_total_io_count) { /* no IOs completed in interval */
if (0 == (++ioTimeoutCount % args->ioTimeout)) { /* no progress after modulo ioTimeout interval */
if (args->flags & CLD_FLG_TMO_ERROR) {
args->test_state =
SET_STS_FAIL(args->test_state);
env->bContinue = FALSE;
msg_level = ERR;
}
pMsg(msg_level, args,
"Possible IO hang condition, IO timeout reached, %lu seconds\n",
args->ioTimeout);
}
#ifdef _DEBUG
PDBG3(DBUG, args, "io timeout count: %lu\n",
ioTimeoutCount);
#endif
} else {
ioTimeoutCount = 0;
last_total_io_count = cur_total_io_count;
#ifdef _DEBUG
PDBG3(DBUG, args, "io timeout reset\n");
#endif
}
if (((args->hbeat > 0) && ((run_time % args->hbeat) == 0))
|| (signal_action & SIGNAL_STAT)) {
print_stats(args, env, HBEAT);
update_cyc_stats(env);
clear_stat_signal();
}
if (glb_run == 0) {
break;
} /* global run flag cleared */
if (signal_action & SIGNAL_STOP) {
break;
}
/* user request to stop */
if (args->flags & CLD_FLG_TMD) { /* if timing */
if (run_time >= args->run_time) { /* and run time exceeded */
break;
}
} else { /* if not timing */
if (env->kids <= 1) { /* and the timer is the only child */
break;
}
}
} while (TRUE);
#ifdef _DEBUG
PDBG3(DBUG, args, "Out of timer %lu, %lu, %d, %d\n", time(NULL),
run_time, env->bContinue, env->kids);
#endif
if (args->flags & CLD_FLG_TMD) { /* timed test, timer exit needs to stop io threads */
#ifdef _DEBUG
PDBG3(DBUG, args,
"Setting bContinue to FALSE, timed test & timer exit\n");
#endif
env->bContinue = FALSE;
}
TEXIT((uintptr_t) GETLASTERROR());
}
