void CAudioSignalPlayer::SetSignalSafe( const char* pName ) { if (pName && pName[0]!=0) SetSignal( pName ); else SetSignal( INVALID_AUDIOSIGNAL_ID ); }
/* Waits for a signal or a timeout */ ULONG ata_WaitTO(struct IORequest* tmr, ULONG secs, ULONG micro, ULONG sigs) { ULONG sig = 1 << tmr->io_Message.mn_ReplyPort->mp_SigBit; D(struct Node *t = (struct Node *)FindTask(NULL)); D(bug("[ATA ] Timed wait %lds %ldu (task='%s')\n", secs, micro, t->ln_Name)); tmr->io_Command = TR_ADDREQUEST; ((struct timerequest*)tmr)->tr_time.tv_secs = secs; ((struct timerequest*)tmr)->tr_time.tv_micro = micro; SendIO(tmr); D(bug("[ATA ] Preset signals: %lx ('%s')\n", SetSignal(0, 0), t->ln_Name)); D(bug("[ATA ] Signals requested: %lx ('%s')\n", sigs, t->ln_Name)); D(bug("[ATA ] Timer signal: %lx ('%s')\n", sig, t->ln_Name)); sigs = Wait(sigs | sig); D(bug("[ATA ] Signals received: %lx ('%s')\n", sigs, t->ln_Name)); if (0 == (sigs & sig)) { if (!CheckIO(tmr)) AbortIO(tmr); } WaitIO(tmr); SetSignal(0, sig); return sigs & ~sig; }
ULONG check_signals(void) { ULONG mask; if (_ChkSignalLockout) return 0L; ++_ChkSignalLockout; mask = ((struct Task *) FindTask(NULL))->tc_SigRecvd; /* Default Ctrl-C handling */ if (!sys_signal_hup && (mask & SIGBREAKF_CTRL_C)) { SetSignal(0L, SIGBREAKF_CTRL_C); write(2, "*** Break.\n", 11); exit(EXIT_FAILURE); } /* Handle our special exceptions */ if (mask & sys_signal_alarm) { (*handler_alarm) (); SetSignal(0L, sys_signal_alarm); } if (mask & sys_signal_hup) { (*handler_hup) (); SetSignal(0L, sys_signal_hup); } if (mask & sys_signal_usr) { (*handler_usr) (); SetSignal(0L, sys_signal_usr); } --_ChkSignalLockout; return mask; }
//----------------------------------------------------------------------------- // Sets processing function for all signals, which we want to handle // crash - whether to catch the crash signals too // Returns: error number int SetSignals(bool crash) { int ret; int exitSignals[] = { SIGPWR, SIGQUIT, SIGINT, SIGTERM }; int crashSignals[] = { SIGBUS, SIGFPE, SIGSEGV, SIGSYS, SIGILL, SIGSTKFLT, SIGXFSZ }; int i; int count; // Exit signals count = (int)(sizeof(exitSignals) / sizeof(int)); for(i = 0; i < count; i++) { ret = SetSignal(exitSignals[i]); if(ret) { printf("ERROR: Can't set exit signal '%s': %s\n", strsignal(exitSignals[i]), strerror(ret)); return ret; } } // Crash signals if(crash) { count = (int)(sizeof(crashSignals) / sizeof(int)); for(i = 0; i < count; i++) { ret = SetSignal(crashSignals[i]); if(ret) { printf("ERROR: Can't set crash signal '%s': %s\n", strsignal(crashSignals[i]), strerror(ret)); return ret; } } } return 0; }
void SetAllSignals(void) { SetSignal(SIGINT, &SignalHandler); SetSignal(SIGTERM, &SignalHandler); SetSignal(SIGQUIT, &SignalHandler); return; }
/********************************************************************** * Function: ChangeName * Description: This function will set the name of service, topic, or item * based on the ctrlID parameter. If the service name changes * it will change the list of topics and items * * ***********************************************************************/ int OBJDCLASS::ChangeName(LPSTR name, int ctrlID) { int rVal = 0;; HWND hCtrl = GetDlgItem(hDlg, ctrlID); switch (ctrlID) { case IDSIGNAL: { SetSignal(name); if (strcmp(name, "") == 0) { ResetAddFlag(SIGS_ADDEDSIGNAL); rVal = 1; } else { SetAddFlag(SIGS_ADDEDSIGNAL); rVal = 0; } } break; default: return 0; } I_UNUSED(hCtrl); return rVal; }
/* * Clean up Sana-II Interfaces * * Note: main interface queue is SNAFU after deinitializing */ void sana_deinit(void) { struct sana_softc *ssc; struct IOSana2Req *req; assert(SanaPort); while (ssq) { sana_down(ssq); if (ssq->ss_if.if_flags & IFF_RUNNING) { sana_unrun(ssq); } ssc = ssq; ssq = ssc->ss_next; /* Close device */ req = CreateIOSana2Req(ssc); if (req) { CloseDevice((struct IORequest*)req); DeleteIOSana2Req(req); } else { __log(LOG_ERR, "sana_deinit(): Couldn't close device %s\n", ssc->ss_name); } } if (SanaPort) { /* Clear possible pending signals */ SetSignal(1<<SanaPort->mp_SigBit, 0L); DeleteMsgPort(SanaPort); SanaPort = NULL; } }
static void ExpungeUnit ( struct AHIDevUnit *iounit, struct AHIBase *AHIBase ) { struct Task *unittask; BYTE signal; signal = AllocSignal(-1); if(signal == -1) { /* Fallback */ signal = SIGB_SINGLE; SetSignal(0, SIGF_SINGLE); } unittask = (struct Task *) iounit->Process; iounit->Process = (struct Process *) FindTask(NULL); iounit->SyncSignal = signal; Signal(unittask,SIGBREAKF_CTRL_F); Wait(1UL << signal); AHIBase->ahib_DevUnits[iounit->UnitNum]=NULL; FreeVec(iounit->Voices); FreeVec(iounit); if(signal != SIGB_SINGLE) { FreeSignal(signal); } }
void Sys_Net_Wait(struct SysNetData *netdata, struct SysSocket *socket, unsigned int timeout_us) { fd_set rfds; ULONG sigmask; WaitIO((struct IORequest *)netdata->timerrequest); if (SetSignal(0, 0) & (1<<netdata->timerport->mp_SigBit)) Wait(1<<netdata->timerport->mp_SigBit); FD_ZERO(&rfds); FD_SET(socket->s, &rfds); netdata->timerrequest->tr_node.io_Command = TR_ADDREQUEST; netdata->timerrequest->tr_time.tv_secs = timeout_us / 1000000; netdata->timerrequest->tr_time.tv_micro = timeout_us % 1000000; SendIO((struct IORequest *)netdata->timerrequest); sigmask = 1<<netdata->timerport->mp_SigBit; WaitSelect(socket->s + 1, &rfds, 0, 0, 0, &sigmask); AbortIO((struct IORequest *)netdata->timerrequest); }
int MyExecute (char **argv) { char * buffer, * ptr; char ** aptr; int len = 0; int status; for (aptr=argv; *aptr; aptr++) { len += strlen (*aptr) + 4; } buffer = AllocMem (len, MEMF_ANY); if (!buffer) fatal (NILF, "MyExecute: Cannot allocate space for calling a command"); ptr = buffer; for (aptr=argv; *aptr; aptr++) { if (((*aptr)[0] == ';' && !(*aptr)[1])) { *ptr ++ = '"'; strcpy (ptr, *aptr); ptr += strlen (ptr); *ptr ++ = '"'; } else if ((*aptr)[0] == '@' && (*aptr)[1] == '@' && !(*aptr)[2]) { *ptr ++ = '\n'; continue; } else { strcpy (ptr, *aptr); ptr += strlen (ptr); } *ptr ++ = ' '; *ptr = 0; } ptr[-1] = '\n'; status = SystemTags (buffer, SYS_UserShell, TRUE, TAG_END); FreeMem (buffer, len); if (SetSignal (0L,0L) & SIGBREAKF_CTRL_C) status = 20; /* Warnings don't count */ if (status == 5) status = 0; return status; }
void __interrupt __chkabort (void) { if (SetSignal(0, SIGBREAKF_CTRL_C|SIGBREAKF_CTRL_D) & SIGBREAKF_CTRL_C) { raise(SIGINT); } }
static void* CreateConnectionData(DBusConnection* connection) { struct ConnectionData* c = AllocVec(sizeof(struct ConnectionData), MEMF_ANY|MEMF_CLEAR); kprintf("CreateConnectionData %08lx\n", c); if (c != NULL) { c->connection = connection; c->creator = FindTask(NULL); NewList((struct List*) &c->watches); Forbid(); kprintf("creating mainloop\n"); c->main = (struct Task*) CreateNewProcTags(NP_Entry, (ULONG) MainLoop, NP_Name, (ULONG) "dbus.library main loop", NP_Priority, 0, TAG_DONE); kprintf("created mainloop %08lx\n", c->main); if (c->main != NULL) { c->main->tc_UserData = c; } SetSignal(0, SIGF_SINGLE); Permit(); Wait(SIGF_SINGLE); if (c->main == NULL) { DeleteConnectionData(c); c = NULL; } } return c; }
VOID __saveds PingFunc( VOID ) { struct MsgPort *ClientPort, *ReplyPort; struct Library *SysBase; BlankMsg PingMsg; SysBase = *( struct Library ** )4L; if( ReplyPort = CreateMsgPort()) { PingMsg.bm_Mess.mn_ReplyPort = ReplyPort; PingMsg.bm_Mess.mn_Length = sizeof( BlankMsg ); PingMsg.bm_Type = BM_PING; /* Stealthimania, to alleviate processing at the blanker */ PingMsg.bm_Mess.mn_Node.ln_Name = ( UBYTE * )( &Blanking ); for( ;; ) { if( SetSignal( 0L, SIGBREAKF_CTRL_C ) & SIGBREAKF_CTRL_C ) break; if( ClientPort = FindPort( "GarshneClient" )) { PingMsg.bm_Flags = 0L; PutMsg( ClientPort, ( struct Message * )( &PingMsg )); WaitPort( ReplyPort ); GetMsg( ReplyPort ); } } DeletePort( ReplyPort ); } }
//___________________________________________________________________________ KVChannelVolt::KVChannelVolt(const Char_t* signal, KVDetector* kvd): KVCalibrator (3) { //Create an electronic calibration object for a specific detector (*kvd) //specifying the signal type ("PG" - petit "low" gain - or "GG" - grand "high" gain) SetType("Channel-Volt"); SetDetector(kvd); SetSignal(signal); SetGainRef(1); }
LONG ContinueBlanking( VOID ) { if( SetSignal( 0L, SIGBREAKF_CTRL_C ) & SIGBREAKF_CTRL_C ) return QUIT; if( StopIt ) return QUIT; return OK; }
static void StartEventHandler(KonohaContext *kctx, void *args) { KNH_ASSERT(PLATAPI eventContext == NULL); struct EventContext *eventContext = (struct EventContext *)PLATAPI malloc_i(sizeof(struct EventContext)); ((KonohaFactory *)kctx->platApi)->eventContext = eventContext; bzero(((KonohaFactory *)kctx->platApi)->eventContext, sizeof(struct EventContext)); eventContext->queue = (LocalQueue *)PLATAPI malloc_i(sizeof(LocalQueue)); LocalQueue_Init(kctx, eventContext->queue); SetSignal(kctx); }
int main(int argc, char *argv[]) { int cnt; char buf[BUFSIZE+1]; SetSignal(0,SIGBREAKF_CTRL_C); while(1) { cnt=EM_getlog(buf,BUFSIZE); if(cnt<0) { fprintf(stderr,"An error occured while reading logs\n"); exit(10); } buf[cnt]='\0'; printf("%s",buf); if(SetSignal(0,SIGBREAKF_CTRL_C)&SIGBREAKF_CTRL_C) break; } exit(0); }
static void DeleteConnectionData(struct ConnectionData* c) { kprintf("DeleteConnectionData %08lx\n", c); if (c != NULL) { if (c->main != NULL) { SetSignal(0, SIGF_SINGLE); Signal(c->main, SIGBREAKF_CTRL_C); Wait(SIGF_SINGLE); } FreeVec(c); } }
void gotControlC(void) { #ifdef FOOBAR if ((SetSignal(0, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) != 0) { (void) Write(dos_fh, "Interrupt!!!\n", 13); ISt->is_argBool = TRUE; return; } #endif ISt->is_argBool = FALSE; return; }
/* /// "usbForceInterfaceBinding()" */ struct NepClassHid * usbForceInterfaceBinding(struct NepHidBase *nh, struct PsdInterface *pif) { struct Library *ps; struct NepClassHid *nch; struct PsdConfig *pc; struct PsdDevice *pd; STRPTR devname; UBYTE buf[64]; struct Task *tmptask; KPRINTF(1, ("nepHidAttemptInterfaceBinding(%08lx)\n", pif)); if((ps = OpenLibrary("poseidon.library", 4))) { if((nch = psdAllocVec(sizeof(struct NepClassHid)))) { nch->nch_ClsBase = nh; nch->nch_Device = NULL; nch->nch_Interface = pif; nLoadClassConfig(nh); psdSafeRawDoFmt(buf, 64, "simplemidi.class<%08lx>", nch); nch->nch_ReadySignal = SIGB_SINGLE; nch->nch_ReadySigTask = FindTask(NULL); SetSignal(0, SIGF_SINGLE); if((tmptask = psdSpawnSubTask(buf, nHidTask, nch))) { psdBorrowLocksWait(tmptask, 1UL<<nch->nch_ReadySignal); if(nch->nch_Task) { nch->nch_ReadySigTask = NULL; //FreeSignal(nch->nch_ReadySignal); psdGetAttrs(PGA_INTERFACE, pif, IFA_Config, &pc, TAG_END); psdGetAttrs(PGA_CONFIG, pc, CA_Device, &pd, TAG_END); psdGetAttrs(PGA_DEVICE, pd, DA_ProductName, &devname, TAG_END); psdAddErrorMsg(RETURN_OK, (STRPTR) libname, "Play it again, '%s'!", devname); CloseLibrary(ps); return(nch); } } nch->nch_ReadySigTask = NULL; //FreeSignal(nch->nch_ReadySignal); psdFreeVec(nch); } CloseLibrary(ps); } return(NULL); }
ULONG amigaGetTriggerSigs(void) { ULONG trigs = 0, sigr; sigr = SetSignal(0L,0L); if ( sigr & SIGBREAKF_CTRL_C ) trigs |= DNETC_MSG_SHUTDOWN; #ifndef NO_GUI if ( DnetcBase && ModeReqIsSet(-1) ) trigs |= dnetcguiHandleMsgs(sigr); #endif #ifndef __OS3PPC__ /* ** 68K / OS4 / MorphOS */ if ( TriggerPort && sigr & 1L << TriggerPort->mp_SigBit ) { struct TriggerMessage *msg; while ((msg = (struct TriggerMessage *)GetMsg(TriggerPort))) { trigs |= msg->tm_TriggerType; ReplyMsg((struct Message *)msg); } } #elif !defined(__POWERUP__) /* ** WarpOS */ if ( TriggerPort && sigr & 1L << TriggerPort->mp_Port.mp_SigBit ) { struct TriggerMessage *msg; while ((msg = (struct TriggerMessage *)GetMsgPPC(TriggerPort))) { trigs |= msg->tm_TriggerType; ReplyMsgPPC((struct Message *)msg); } } #else /* ** PowerUp */ { void *msg; while ((msg = PPCGetMessage(TriggerPort))) { trigs |= PPCGetMessageAttr(msg,PPCMSGTAG_MSGID); PPCReplyMessage(msg); } } #endif return(trigs); }
static struct Task *create_inputtask( struct inputtask_params *params) { struct Task *task; APTR stack; task = AllocMem(sizeof (struct Task), MEMF_PUBLIC|MEMF_CLEAR); if (NULL != task) { NEWLIST(&task->tc_MemEntry); task->tc_Node.ln_Type=NT_TASK; task->tc_Node.ln_Name= INPUTTASK_NAME; task->tc_Node.ln_Pri = INPUTTASK_PRIORITY; stack=AllocMem(INPUTTASK_STACKSIZE, MEMF_PUBLIC); if(NULL != stack) { task->tc_SPLower=stack; task->tc_SPUpper=(BYTE *)stack + INPUTTASK_STACKSIZE; task->tc_UserData=params; #if AROS_STACK_GROWS_DOWNWARDS task->tc_SPReg=(BYTE *)task->tc_SPUpper-SP_OFFSET-sizeof(APTR); #else task->tc_SPReg=(BYTE *)task->tc_SPLower-SP_OFFSET+sizeof(APTR); #endif /* You have to clear signals first. */ SetSignal(0, params->ok_signal | params->nok_signal); if(AddTask(task, inputtask_entry, NULL) != NULL) { /* Everything went OK. Wait for task to initialize */ ULONG sigset; D(bug("WAITING FOR SIGNAL\n")); sigset = Wait( params->ok_signal | params->nok_signal ); D(bug("GOT SIGNAL\n")); if (sigset & params->ok_signal) return task; } FreeMem(stack, INPUTTASK_STACKSIZE); } FreeMem(task,sizeof(struct Task)); } return NULL; }
void ether_exit(void) { // Stop process if (net_proc) { SetSignal(0, SIGF_SINGLE); Signal(&net_proc->pr_Task, SIGBREAKF_CTRL_C); Wait(SIGF_SINGLE); } // Delete reply port if (reply_port) { DeleteMsgPort(reply_port); reply_port = NULL; } }
static void SmallDelay(struct ExecBase *SysBase) { struct Interrupt i; i.is_Code = (APTR)AHITimerTickCode; i.is_Data = FindTask(0); i.is_Node.ln_Name = "AROS AHI Driver Timer Tick Server"; i.is_Node.ln_Pri = 0; i.is_Node.ln_Type = NT_INTERRUPT; SetSignal(0, SIGBREAKF_CTRL_F); AddIntServer(INTB_TIMERTICK, &i); Wait(SIGBREAKF_CTRL_F); RemIntServer(INTB_TIMERTICK, &i); }
ULONG TellWBTaskToCloseWindows(struct IntuitionBase *IntuitionBase) { DEBUG_WORKBENCH(dprintf("TellWBTaskToCloseWindows: currenttask <%s>\n", FindTask(NULL)->tc_Node.ln_Name)); if ( GetPrivIBase(IntuitionBase)->WorkBenchMP != NULL && GetPrivIBase(IntuitionBase)->WorkBenchMP->mp_SigTask != FindTask(NULL) ) { struct MsgPort replymp; struct IntuiMessage imsg; /* Setup our reply port. By doing this manually, we can use SIGB_SINGLE * and thus avoid allocating a signal (which may fail). */ memset( &replymp, 0, sizeof( replymp ) ); replymp.mp_Node.ln_Type = NT_MSGPORT; replymp.mp_Flags = PA_SIGNAL; replymp.mp_SigBit = SIGB_SINGLE; replymp.mp_SigTask = FindTask( NULL ); NEWLIST( &replymp.mp_MsgList ); /* Setup our message */ imsg.ExecMessage.mn_ReplyPort = &replymp; imsg.Class = IDCMP_WBENCHMESSAGE; imsg.Code = WBENCHCLOSE; SetSignal(0, SIGF_SINGLE); DEBUG_WORKBENCH(dprintf("TellWBTaskToCloseWindows: Send Msg\n")); /* Sends it to the handler and wait for the reply */ PutMsg( GetPrivIBase(IntuitionBase)->WorkBenchMP, (struct Message *) &imsg ); WaitPort( &replymp ); /* After leaving this block imsg and repymp will be automagically freed, * so we don't have to deallocate them ourselves. */ DEBUG_WORKBENCH(dprintf("TellWBTaskToCloseWindows: done\n")); return(TRUE); } else { DEBUG_WORKBENCH(dprintf("TellWBTaskToCloseWindows: no Workbench port\n")); } return(FALSE); }
int16 ASERDPort::close() { // Stop process if (serial_proc) { SetSignal(0, SIGF_SINGLE); Signal(&serial_proc->pr_Task, SIGBREAKF_CTRL_C); Wait(SIGF_SINGLE); } // Delete reply port if (reply_port) { DeleteMsgPort(reply_port); reply_port = NULL; } return noErr; }
int16 ASERDPort::open(uint16 config) { // Don't open NULL name devices if (device_name == NULL) return openErr; // Init variables err_mask = 0; // Create message port reply_port = CreateMsgPort(); if (reply_port == NULL) goto open_error; // Start process proc_error = false; proc_arg = this; SetSignal(0, SIGF_SINGLE); serial_proc = CreateNewProcTags( NP_Entry, (ULONG)serial_func, NP_Name, (ULONG)"Basilisk II Serial Task", NP_Priority, 1, TAG_END ); if (serial_proc == NULL) goto open_error; // Wait for signal from process Wait(SIGF_SINGLE); // Initialization error? Then bail out if (proc_error) goto open_error; // Configure port configure(config); return noErr; open_error: serial_proc = NULL; if (reply_port) { DeleteMsgPort(reply_port); reply_port = NULL; } return openErr; }
bool ether_init(void) { // Do nothing if no Ethernet device specified if (PrefsFindString("ether") == NULL) return false; // Initialize protocol list NewList(&prot_list); // Create message port reply_port = CreateMsgPort(); if (reply_port == NULL) goto open_error; D(bug("signal mask %08lx\n", 1 << reply_port->mp_SigBit)); // Start process proc_error = false; SetSignal(0, SIGF_SINGLE); net_proc = CreateNewProcTags( NP_Entry, (ULONG)net_func, NP_Name, (ULONG)"Basilisk II Ethernet Task", NP_Priority, 1, TAG_END ); if (net_proc == NULL) goto open_error; // Wait for signal from process Wait(SIGF_SINGLE); // Initialization error? Then bail out if (proc_error) goto open_error; // Everything OK return true; open_error: net_proc = NULL; if (reply_port) { DeleteMsgPort(reply_port); reply_port = NULL; } return false; }
int LCDA::OnVolts(MM::PropertyBase* pProp, MM::ActionType eAct) { if (eAct == MM::BeforeGet) { float volts; int ret = LaserBoardGetAOV(channel_ - 1, &volts); if (ret != DEVICE_OK) return ret; pProp->Set((double)volts); } else if (eAct == MM::AfterSet) { double volts; pProp->Get(volts); return SetSignal((double) volts); } return DEVICE_OK; }
static int ata_expunge(struct ataBase *ATABase) { if (ATABase->ataObj) { /* * CLID_Hidd_Storage is a singletone, you can get it as many times as * you want. Here we save up some space in struct ataBase by * obtaining storageRoot object only when we need it. This happens * rarely, so small performance loss is OK here. */ OOP_Object *storageRoot = OOP_NewObject(NULL, CLID_Hidd_Storage, NULL); if (storageRoot && HW_RemoveDriver(storageRoot, ATABase->ataObj)) { /* Destroy our singletone */ OOP_MethodID disp_msg = OOP_GetMethodID(IID_Root, moRoot_Dispose); D(bug("[ATA ] ata_expunge: Stopping Daemon...\n")); ATABase->daemonParent = FindTask(NULL); SetSignal(0, SIGF_SINGLE); Signal(ATABase->ata_Daemon, SIGBREAKF_CTRL_C); Wait(SIGF_SINGLE); D(bug("[ATA ] ata_expunge: Done, destroying subystem object\n")); OOP_DoSuperMethod(ATABase->ataClass, ATABase->ataObj, &disp_msg); } else { /* Our subsystem is in use, we have some bus driver(s) around. */ D(bug("[ATA ] ata_expunge: ATA subsystem is in use\n")); return FALSE; } } D(bug("[ATA ] ata_expunge: Releasing attribute bases\n")); OOP_ReleaseAttrBasesArray(&ATABase->hwAttrBase, attrBaseIDs); if (ATABase->ata_UtilityBase) CloseLibrary(ATABase->ata_UtilityBase); D(bug("[ATA ] ata_expunge: Exiting\n")); return TRUE; }