/* call a callback function for each used channel */ BOOL cm__chan_foreach(BOOL (*func)(), VOID *a1, VOID *a2) { INT n; BOOL ret = TRUE; D_LOG(D_ENTRY, ("cm__chan_foreach: entry, func: %lx, a1: 0x%lx, a2: 0x%lx", \ func, a1, a2)); for ( n = 0 ; n < MAX_CHAN_IN_SYSTEM ; n++ ) if ( chan_used[n] ) { CM_CHAN *chan = chan_tbl + n; D_LOG(D_ALWAYS, ("cm__chan_foreach: calling for chan# %d, channel: %lx", n, chan)); ret = (*func)(chan, a1, a2); D_LOG(D_ALWAYS, ("cm__chan_foreach: returned %d", ret)); if ( !ret ) break; } return(ret); }
/* find a matching listening connection */ CM* cm__find_listen_conn(CHAR *lname, CHAR *rname, CHAR *addr, VOID *Idd) { CM *cm; ULONG n; D_LOG(D_ENTRY, ("cm__find_listen_conn: entry, lname: [%s], rname: [%s], addr: [%s]", \ lname, rname, addr)); /* scan connection table */ for ( n = 0; n < MAX_CM_IN_SYSTEM ; n++) { cm = cm_tbl[n]; if ( cm_used[n] && (cm->idd == Idd) && (cm->state == CM_ST_LISTEN) ) { D_LOG(D_ENTRY, ("cm__find_listen_conn: comparing to: name: [%s], remote_name: [%s]", \ cm->dprof.name, cm->dprof.remote_name)); if ( cm__match_str(cm->dprof.name, rname) && cm__match_str(cm->dprof.remote_name, lname) ) return(cm); } } return(NULL); }
cl_int MemoryObjectWrapper::createSubBuffer (cl_mem_flags aFlags, RegionWrapper const& aRegion, MemoryObjectWrapper** aResultOut) { #if CL_WRAPPER_CL_VERSION_SUPPORT >= 110 D_METHOD_START; cl_int err = CL_SUCCESS; VALIDATE_ARG_POINTER (aResultOut, &err, err); cl_buffer_region region; region.origin = aRegion.origin; region.size = aRegion.size; cl_mem mem = clCreateSubBuffer (mWrapped, aFlags, CL_BUFFER_CREATE_TYPE_REGION, (void const*)®ion, &err); if (err != CL_SUCCESS || !mem) D_LOG (LOG_LEVEL_ERROR, "clCreateSubBuffer failed. (error %d)", err); // NOTE: clCreateSubBuffer can return an existing handle. *aResultOut = MemoryObjectWrapper::getNewOrExisting (mem); return err; #else // CL_WRAPPER_CL_VERSION_SUPPORT >= 110 (void)aFlags; (void)aRegion; (void)aResultOut; D_LOG (LOG_LEVEL_ERROR, "CLWrapper support for OpenCL 1.1 API was not enabled at build time."); return CL_INVALID_VALUE; #endif }
void direct_trap( const char *domain, int sig ) { sigval_t val; if (direct_config->delay_trap_ms) { D_LOG( Direct_Trap, VERBOSE, "NOT RAISING signal %d from %s, waiting for %dms... attach gdb --pid=%d\n", sig, domain, direct_config->delay_trap_ms, getpid() ); direct_thread_sleep( direct_config->delay_trap_ms * 1000LL ); return; } D_LOG( Direct_Trap, VERBOSE, "Raising signal %d from %s...\n", sig, domain ); val.sival_int = direct_gettid(); #ifndef DIRECT_BUILD_NO_SIGQUEUE sigqueue( direct_gettid(), sig, val ); #endif // direct_tgkill( direct_getpid(), direct_gettid(), sig ); D_LOG( Direct_Trap, VERBOSE, "...tgkill(%d) on ourself returned, maybe blocked, calling abort()!\n", sig ); abort(); D_LOG( Direct_Trap, VERBOSE, "...abort() returned as well, calling %s()!\n", #ifdef __NR_exit_group "exit_group" ); syscall( __NR_exit_group, DR_BUG ); #else "_exit" ); _exit( DR_BUG ); #endif }
/* add a channel to channel table */ mtl_add_chan(VOID *mtl_1, VOID *idd, USHORT bchan, ULONG speed, ULONG ConnectionType) { MTL *mtl = (MTL*)mtl_1; INT ret = MTL_E_SUCC; MTL_CHAN *chan; INT n; D_LOG(D_ENTRY, ("mtl_add_chan: entry, mtl: 0x%lx, idd: 0x%lx, bchan: %d, speed: 0x%x\n", \ mtl, idd, bchan, speed)); /* lock */ NdisAcquireSpinLock(&mtl->chan_tbl.lock); /* check for space */ if ( mtl->chan_tbl.num >= MAX_CHAN_PER_CONN ) ret = MTL_E_NOROOM; else { /* find free slot, MUST find! */ for ( chan = mtl->chan_tbl.tbl, n = 0 ; n < MAX_CHAN_PER_CONN ; n++, chan++ ) if ( !chan->idd ) break; if ( n >= MAX_CHAN_PER_CONN ) { D_LOG(DIGIMTL, ("mtl_add_chan: not free slot when num < MAX!\n")); ret = MTL_E_NOROOM; } else { /* slot found, fill it */ mtl->chan_tbl.num++; if (ConnectionType == CM_DKF) { mtl->IddTxFrameType = IDD_FRAME_DKF; mtl->SendFramingBits = RAS_FRAMING; } else { mtl->IddTxFrameType = IDD_FRAME_PPP; mtl->SendFramingBits = PPP_FRAMING; } chan->idd = idd; chan->bchan = bchan; chan->speed = speed; chan->mtl = mtl; /* add handler for slot */ idd_attach(idd, bchan, (VOID*)mtl__rx_bchan_handler, chan); } } /* release & return */ NdisReleaseSpinLock(&mtl->chan_tbl.lock); D_LOG(D_EXIT, ("mtl_add_chan: exit, ret: %d\n", ret)); return(ret); }
/* do timer tick processing for rx side */ VOID mtl__rx_tick(MTL *mtl) { INT n; MTL_AS *as; MTL_RX_TBL *RxTable = &mtl->rx_tbl; // // see if there are any receives to give to wrapper // IndicateRxToWrapper(mtl); NdisAcquireSpinLock(&mtl->lock); NdisAcquireSpinLock(&RxTable->lock); /* scan assembly table */ for ( n = 0, as = RxTable->as_tbl ; n < MTL_RX_BUFS ; n++, as++ ) { /* update ttl & check */ if ( as->tot && !(as->ttl -= 25) ) { D_LOG(D_ALWAYS, ("mtl__rx_bchan_handler: Pkt Kill ttl = 0: Slot: %d, mtl: 0x%p", n, mtl)); D_LOG(D_ALWAYS, ("AS Timeout! mtl: 0x%p, as: 0x%p, as->seq: 0x%x", mtl, as, as->seq)); D_LOG(D_ALWAYS, ("as->tot: %d, as->num: %d", as->tot, as->num)); RxTable->TimeOutReceiveError1++; // // if this guy was queued for indication to wrapper // and was not indicated within a second something is wrong // if (as->Queued) { D_LOG(D_ALWAYS, ("AS Timeout while queued for indication! mtl: 0x%p, as: 0x%p", mtl, as)); #if DBG DbgBreakPoint(); #endif } as->tot = 0; // // mark this guy as being free // as->Queued = 0; } } NdisReleaseSpinLock(&RxTable->lock); NdisReleaseSpinLock(&mtl->lock); }
/* get mac mtu on connection */ mtl_get_mac_mtu(VOID *mtl_1, ULONG *mtu) { MTL *mtl = (MTL*)mtl_1; D_LOG(D_ENTRY, ("mtl_get_mac_mtu: entry, mtl: 0x%lx, @mtu: 0x%lx\n", mtl, mtu)); *mtu = MTL_MAC_MTU; D_LOG(D_EXIT, ("mtl_get_mac_mtu: exit, mtu: %ld\n", *mtu)); return(MTL_E_SUCC); }
/* handler for trace and dump area data packets */ VOID trc__cmd_handler(VOID *idd_1, USHORT chan, ULONG Reserved, IDD_MSG *msg) { TRC *trc; TRC_ENTRY *ent; IDD *idd = (IDD*)idd_1; D_LOG(D_ENTRY, ("trc__cmd_handler: idd: %lx, chan: %d, msg: %lx", \ idd, chan, msg)); D_LOG(D_ENTRY, ("trc__cmd_handler: opcode: 0x%x, buflen: 0x%x, bufptr: %lx", \ msg->opcode, msg->buflen, msg->bufptr)); D_LOG(D_ENTRY, ("trc__cmd_handler: bufid: %lx, param: 0x%x", \ msg->bufid, msg->param)); // Get the trace object for this idd trc = idd_get_trc(idd); // if no obect exit if (trc == NULL || msg->bufid >= 2) return; /* if here it is a trace frame. param is rx/tx attribute */ /* establish entry to insert into & update vars */ /* check if trace enabled */ if ( trc->stat.state == TRC_ST_STOP ) return; D_LOG(D_ALWAYS, ("trc__cmd_handler: trc: %lx", trc)); /* check if frame filters in */ if ( !trc__filter(trc->stat.filter, msg->bufptr, msg->buflen) ) return; /* frames needs to be buffered, establish entry pointer */ ent = trc->ent_tbl + trc->ent_put; trc->ent_put = (trc->ent_put + 1) % trc->stat.depth; if ( trc->ent_num < trc->stat.depth ) trc->ent_num++; /* fill up entry */ ent->seq = trc->ent_seq++; KeQuerySystemTime(&ent->time_stamp); ent->attr = msg->bufid; ent->org_len = msg->buflen; ent->len = MIN(msg->buflen, sizeof(ent->data)); IddGetDataFromAdapter(idd, (PUCHAR)ent->data, (PUCHAR)msg->bufptr, (USHORT)ent->len); // NdisMoveMemory (ent->data, msg->bufptr, ent->len); }
static void call_handlers( int num, void *addr ) { DirectLink *l, *n; if (num == SIG_DUMP_STACK) num = DIRECT_SIGNAL_DUMP_STACK; /* Loop through all handlers. */ direct_mutex_lock( &handlers_lock ); direct_list_foreach_safe (l, n, handlers) { DirectSignalHandler *handler = (DirectSignalHandler*) l; if (handler->removed) { direct_list_remove( &handlers, &handler->link ); D_MAGIC_CLEAR( handler ); D_FREE( handler ); continue; } D_LOG( Direct_Signals, FATAL, " --> %d\n", handler->num ); if (handler->num != num && handler->num != DIRECT_SIGNAL_ANY) continue; if (handler->num == DIRECT_SIGNAL_ANY && num == DIRECT_SIGNAL_DUMP_STACK) continue; switch (handler->func( num, addr, handler->ctx )) { case DSHR_OK: break; case DSHR_REMOVE: direct_list_remove( &handlers, &handler->link ); D_MAGIC_CLEAR( handler ); D_FREE( handler ); break; case DSHR_RESUME: D_LOG( Direct_Signals, FATAL, " '-> cured!\n" ); direct_mutex_unlock( &handlers_lock ); return; default: D_BUG( "unknown result" ); break; } }
cl_int EventWrapper::setUserEventStatus (cl_int aExecutionStatus) { #if CL_WRAPPER_CL_VERSION_SUPPORT >= 110 D_METHOD_START; cl_int err = clSetUserEventStatus (mWrapped, aExecutionStatus); if (err != CL_SUCCESS) { D_LOG (LOG_LEVEL_ERROR, " clSetUserEventStatus failed. (error %d)", err); } return err; #else // CL_WRAPPER_CL_VERSION_SUPPORT >= 110 (void)aExecutionStatus; D_LOG (LOG_LEVEL_ERROR, "CLWrapper support for OpenCL 1.1 API was not enabled at build time."); return CL_INVALID_VALUE; #endif }
cl_int MemoryObjectWrapper::getGLObjectInfo (cl_gl_object_type *aGLObjectTypeOut, cl_GLuint *aGLObjectNameOut) { #ifdef CL_WRAPPER_ENABLE_OPENGL_SUPPORT D_METHOD_START; cl_int err = clGetGLObjectInfo (mWrapped, aGLObjectTypeOut, aGLObjectNameOut); if (err != CL_SUCCESS) D_LOG (LOG_LEVEL_ERROR, "clGetGLObjectInfo failed. (error %d)", err); return err; #else //CL_WRAPPER_ENABLE_OPENGL_SUPPORT (void)aGLObjectTypeOut; (void)aGLObjectNameOut; D_LOG (LOG_LEVEL_ERROR, "CLWrapper support for OpenCL/OpenGL interoperability API was not enabled at build time."); return CL_INVALID_VALUE; #endif //CL_WRAPPER_ENABLE_OPENGL_SUPPORT }
/* XXX: fix it to restore all registers */ void tlb_fill(CPUCRISState *env1, target_ulong addr, int is_write, int mmu_idx, uintptr_t retaddr) { TranslationBlock *tb; CPUCRISState *saved_env; int ret; saved_env = env; env = env1; D_LOG("%s pc=%x tpc=%x ra=%p\n", __func__, env->pc, env->debug1, (void *)retaddr); ret = cpu_cris_handle_mmu_fault(env, addr, is_write, mmu_idx); if (unlikely(ret)) { if (retaddr) { /* now we have a real cpu fault */ tb = tb_find_pc(retaddr); if (tb) { /* the PC is inside the translated code. It means that we have a virtual CPU fault */ cpu_restore_state(tb, env, retaddr); /* Evaluate flags after retranslation. */ helper_top_evaluate_flags(); } } cpu_loop_exit(env); } env = saved_env; }
/* free a channel */ VOID cm__chan_free(CM_CHAN *chan) { D_LOG(D_ENTRY, ("cm__chan_free: entry, chan: 0x%lx", chan)); chan_used[chan - chan_tbl] = FALSE; }
// // Allocate free channel pool // VOID ChannelInit(VOID) { NDIS_PHYSICAL_ADDRESS pa = NDIS_PHYSICAL_ADDRESS_CONST(-1, -1); /* allocate memory object */ NdisAllocateMemory((PVOID*)&chan_tbl, sizeof(CM_CHAN) * MAX_CHAN_IN_SYSTEM, 0, pa); if ( chan_tbl == NULL ) { D_LOG(D_ALWAYS, ("ChannelInit: memory allocate failed!")); return; } D_LOG(D_ALWAYS, ("ChannelInit: chan_tbl: 0x%x", chan_tbl)); NdisZeroMemory (chan_tbl, sizeof(CM_CHAN) * MAX_CHAN_IN_SYSTEM); NdisZeroMemory (chan_used, sizeof(chan_used)); }
/* XXX: fix it to restore all registers */ void tlb_fill (target_ulong addr, int is_write, int mmu_idx, void *retaddr) { TranslationBlock *tb; CPUState *saved_env; unsigned long pc; int ret; /* XXX: hack to restore env in all cases, even if not called from generated code */ saved_env = env; env = cpu_single_env; D_LOG("%s pc=%x tpc=%x ra=%x\n", __func__, env->pc, env->debug1, retaddr); ret = cpu_cris_handle_mmu_fault(env, addr, is_write, mmu_idx, 1); if (unlikely(ret)) { if (retaddr) { /* now we have a real cpu fault */ pc = (unsigned long)retaddr; tb = tb_find_pc(pc); if (tb) { /* the PC is inside the translated code. It means that we have a virtual CPU fault */ cpu_restore_state(tb, env, pc); /* Evaluate flags after retranslation. */ helper_top_evaluate_flags(); } } cpu_loop_exit(env); } env = saved_env; }
/* get connection speed, add channels from chan_tbl */ mtl_get_conn_speed(VOID *mtl_1, ULONG *speed) { MTL *mtl = (MTL*)mtl_1; USHORT n; D_LOG(D_ENTRY, ("mtl_get_conn_speed: entry, mtk: 0x%lx, @speed: 0x%lx\n", mtl, speed)); /* get lock, count, release */ NdisAcquireSpinLock(&mtl->chan_tbl.lock); for ( n = 0, *speed = 0 ; n < mtl->chan_tbl.num ; n++ ) *speed += mtl->chan_tbl.tbl[n].speed; NdisReleaseSpinLock(&mtl->chan_tbl.lock); D_LOG(D_EXIT, ("mtl_get_conn_speed: exit, speed: %ld bps\n", *speed)); return(MTL_E_SUCC); }
/* static */ nsresult WebCLKernel::getInstance (cl_kernel aInternal, WebCLKernel** aResultOut, WebCL_LibCLWrapper* aLibWrapper) { nsresult rv = NS_OK; WebCLKernel* existing = 0; if (instanceRegistry.findById (aInternal, &existing)) { NS_IF_ADDREF (*aResultOut = existing); } else { nsCOMPtr<WebCLKernel> obj = do_CreateInstance (WEBCL_KERNEL_CONTRACTID, &rv); if (NS_FAILED (rv)) { D_LOG (LOG_LEVEL_ERROR, "Failed to create instance. rv=%d.", rv); return rv; } obj->setWrapper (aLibWrapper); obj->mInternal = aInternal; instanceRegistry.add (obj->mInternal, obj); NS_IF_ADDREF (*aResultOut = obj); } return rv; }
/* issue an element request to idp cm port */ INT cm__elem_rq(VOID *idd, USHORT port, CHAR *elem_buf, USHORT elem_len) { IDD_MSG msg; CHAR *p; D_LOG(D_ENTRY|DIGIQ931, ("cm__elem_rq: entry, idd: 0x%lx, port: 0x%d, elem_buf: 0x%lx, elem_len: 0x%d\n", \ idd, port, elem_buf, elem_len)); /* clear outgoing message */ NdisZeroMemory(&msg, sizeof(msg)); /* allocate a local buffer */ if ( !(msg.bufptr = p = ut_get_buf()) ) return(CM_E_NOMEM); /* copy buffer */ adv_ptr(p, elem_buf, (INT)elem_len); /* fillin message structure */ msg.opcode = Q931_ELEM_RQ; msg.buflen = p - msg.bufptr; /* send to idd */ if ( idd_send_msg(idd, &msg, port, (VOID*)cm__q931_cmpl_handler, NULL) != IDD_E_SUCC ) { ut_free_buf(msg.bufptr); return(CM_E_IDD); } return(CM_E_SUCC); }
/* control data transfer on a bchannel */ INT cm__bchan_ctrl_comp(CM_CHAN *chan, ULONG CompressionFlag) { IDD_MSG msg; USHORT Enable = 0; D_LOG(D_ENTRY|DIGIQ931, ("cm__bchan_ctrl_comp: entry, chan: 0x%lx, state: %d\n", \ chan, CompressionFlag)); /* channel must be assigned */ if ( !CM_BCHAN_ASSIGNED(chan->bchan) ) return(CM_E_BADCHAN); /* map channel type to operation */ if ( CompressionFlag ) Enable = COMP_TX_ENA | COMP_RX_ENA; /* build msg */ NdisZeroMemory(&msg, sizeof(msg)); msg.opcode = CMD_COMPRESS; msg.bufid = MAKELONG( chan->bchan | ( Enable << 8 ), 0); /* send it */ idd_send_msg(chan->idd, &msg, IDD_PORT_CMD_TX, NULL, NULL); return(CM_E_SUCC); }
/* format a disconenct request */ INT cm__disc_rq(CM_CHAN *chan) { IDD_MSG msg; D_LOG(D_ENTRY|DIGIQ931, ("cm__disc_rq: entry, chan: 0x%lx\n", chan)); /* clear outgoing message */ NdisZeroMemory(&msg, sizeof(msg)); /* fillin message structure */ msg.opcode = Q931_REL_RQ; msg.bufid = MAKELONG(0, chan->cid); msg.bufptr = ut_get_buf(); msg.buflen = 0; /* send to idd */ if (idd_send_msg(chan->idd, &msg, (USHORT)CM_PORT(chan), (VOID*)cm__q931_cmpl_handler, NULL) != IDD_E_SUCC) ut_free_buf(msg.bufptr); /* turn off channel */ cm__bchan_ctrl(chan, 0); return(CM_E_SUCC); }
/* format a call ignore response */ INT cm__est_ignore( PVOID idd, USHORT cid, USHORT lterm) { IDD_MSG msg; D_LOG(D_ENTRY|DIGIQ931, ("cm__est_ignore: entry, idd: 0x%lx, cid: 0x%x, lterm: 0x%x\n", idd, cid, lterm)); /* clear outgoing message */ NdisZeroMemory(&msg, sizeof(msg)); /* fillin message structure */ msg.opcode = Q931_EST_IGNORE; msg.bufid = MAKELONG(0, cid); msg.bufptr = ut_get_buf(); msg.buflen = 0; /* send to idd */ if (idd_send_msg(idd, &msg, (USHORT)(lterm + IDD_PORT_CM0_TX), (VOID*)cm__q931_cmpl_handler, NULL) != IDD_E_SUCC) ut_free_buf(msg.bufptr); return(CM_E_SUCC); }
/* static */ nsresult WebCLSampler::getInstance (cl_sampler aInternal, WebCLSampler** aResultOut, WebCL_LibCLWrapper* aLibWrapper) { nsresult rv = NS_OK; WebCLSampler* existing = 0; if (instanceRegistry.findById (aInternal, &existing)) { NS_IF_ADDREF (*aResultOut = existing); } else { nsCOMPtr<WebCLSampler> obj ( new WebCLSampler () ); if (!obj) { D_LOG (LOG_LEVEL_ERROR, "Failed to create instance. rv=%d.", rv); return NS_ERROR_OUT_OF_MEMORY; } obj->setWrapper (aLibWrapper); obj->mInternal = aInternal; instanceRegistry.add (obj->mInternal, obj); NS_IF_ADDREF (*aResultOut = obj); } return rv; }
/* set connection state */ mtl_set_conn_state( VOID *mtl_1, USHORT NumberOfChannels, BOOL is_conn) { MTL *mtl = (MTL*)mtl_1; ADAPTER *Adapter = mtl->Adapter; NDIS_PHYSICAL_ADDRESS pa = NDIS_PHYSICAL_ADDRESS_CONST(0xffffffff, 0xffffffff); D_LOG(D_ENTRY, ("mtl_set_conn_state: entry, is_conn: %d\n", is_conn)); /* get lock, set, release & return */ NdisAcquireSpinLock(&mtl->lock); mtl->is_conn = is_conn; // // if we are being notified of a new connection we need to do some stuff // if (is_conn) { mtl->FramesXmitted = 0; mtl->FramesReceived = 0; mtl->BytesXmitted = 0; mtl->BytesReceived = 0; mtl->RecvFramingBits = 0; mtl->tx_tbl.NextFree = 0; mtl->rx_tbl.NextFree = 0; } NdisReleaseSpinLock(&mtl->lock); return(MTL_E_SUCC); }
void Palette::PresetApply(PalettePreset &preset) { static const U16 b_arr[] = { 0, 1, 3, 0, 0, 1, 3, 0, 0, 1, 3, 0, 0, 1, 3 }; static const U16 r_arr[] = { 0, 0, 0, 1, 3, 1, 3, 0, 0, 0, 0, 1, 3, 1, 3 }; static const U16 g_arr[] = { 0, 0, 0, 0, 0, 0, 0, 1, 3, 1, 3, 1, 3, 1, 3 }; const auto &coeffs = preset.CoeffsGet(); const U16 brights[] = { coeffs.zz, coeffs.zn, coeffs.nn, coeffs.zb, coeffs.nb, 0 /*dummy*/, coeffs.bb }; U16 r, g, b; U16 tr, tg, tb; D_LOG(D_DEBUG, D_LOG_MSG("Apply palette preset: %s", CSTR(preset.NameGet()))); clear(); for (auto row = 0; row < PALETTE_ROWS; ++row) { for (auto col = row; col < PALETTE_COLUMS; ++col) { b = brights[b_arr[row] + b_arr[col]]; r = brights[r_arr[row] + r_arr[col]]; g = brights[g_arr[row] + g_arr[col]]; tr = ((r * coeffs.r11) + (g * coeffs.g12) + (b * coeffs.b13)) / (U16)0x100; tg = ((r * coeffs.r21) + (g * coeffs.g22) + (b * coeffs.b23)) / (U16)0x100; tb = ((r * coeffs.r31) + (g * coeffs.g32) + (b * coeffs.b33)) / (U16)0x100; const PaletteItem item(tr, tg, tb); if (TRUE != IsDuplicate(item)) { // Filter duplicate colors. append(item); //D_LOG(D_DEBUG, D_LOG_MSG("row=%i,\tcol=%i,\tr=%i,\tg=%i,\tb=%i", row, col, tr, tg, tb)); } } } }
/* nsIVariant getSamplerInfo (in long aName); */ NS_IMETHODIMP WebCLSampler::GetSamplerInfo(PRInt32 aName, JSContext *cx, nsIVariant **_retval) { D_METHOD_START; NS_ENSURE_ARG_POINTER (_retval); nsresult rv; cl_int err = CL_SUCCESS; int type = getTypeForInfoName (aName); if (type == types::UNKNOWN) { D_LOG (LOG_LEVEL_ERROR, "Info parameter name %d does not have a known type.", aName); WebCL_reportJSError (cx, "Info name %d is not supported by %s.", aName, __FUNCTION__); return WEBCL_XPCOM_ERROR; //NS_ERROR_FAILURE; } nsCOMPtr<nsIWritableVariant> variant = do_CreateInstance(NS_VARIANT_CONTRACTID, &rv); NS_ENSURE_SUCCESS (rv, rv); WEBCL_GETINFO_MEDIATOR_SWITCH (aName, type, mWrapper, getSamplerInfo, mInternal, variant, err, rv); NS_ADDREF (*_retval = variant); return NS_OK; }
/* get an entry by sequence number */ INT trc_get_entry(VOID *trc_1, ULONG seq, TRC_ENTRY *ent) { TRC *trc = (TRC*)trc_1; ULONG n, index; D_LOG(D_ENTRY, ("trc_get_entry: entry, trc: 0x%lx, seq: %ld, ent: 0x%lx", \ trc, seq, ent)); // if no obect exit if (trc == NULL) return(TRC_E_NOSUCH); /* find requested sequence number, temp!!!, using search! */ for ( n = 0 ; n < trc->ent_num ; n++ ) { index = (trc->ent_get + n) % trc->stat.depth; if ( trc->ent_tbl[index].seq == seq ) { /* found */ *ent = trc->ent_tbl[index]; return(TRC_E_SUCC); } } /* if here not found */ return(TRC_E_NOSUCH); }
static bool show_segv( const siginfo_t *info, ucontext_t *uctx ) { switch (info->si_code) { #ifdef SEGV_MAPERR case SEGV_MAPERR: D_LOG( Direct_Signals, FATAL, " --> Caught signal %d (at %p, invalid address) <--\n", info->si_signo, info->si_addr ); return true; #endif #ifdef SEGV_ACCERR case SEGV_ACCERR: D_LOG( Direct_Signals, FATAL, " --> Caught signal %d (at %p, invalid permissions) <--\n", info->si_signo, info->si_addr ); return true; #endif } return false; }
/* filter trace frame */ INT trc__filter(ULONG filter, CHAR *buf, ULONG len) { D_LOG(D_ENTRY, ("trc__filter: entry, filter: %ld, buf: 0x%lx, len: %ld",\ filter, buf, len)); /* not implemented, all frames filter in */ return(1); }
/* completion handler for q931 command with attached local buffers */ VOID cm__q931_cmpl_handler(VOID *arg, USHORT port, IDD_MSG *msg) { D_LOG(D_ENTRY|DIGIQ931, ("cm__q931_cmpl_handler: arg: 0x%lx, port: 0x%d, msg: 0x%lx\n", \ arg, port, msg)); /* free attached buffer */ ut_free_buf(msg->bufptr); }
/* initialize support */ INT res_init(VOID) { NDIS_PHYSICAL_ADDRESS pa = NDIS_PHYSICAL_ADDRESS_CONST(-1, -1); /* allocate memory object */ NdisAllocateMemory((PVOID*)&res__tbl, (sizeof(RES) * MAX_RES), 0, pa); if ( !res__tbl ) { D_LOG(D_ALWAYS, ("res_init: memory allocate failed!")); return(RES_E_NOMEM); } D_LOG(D_ALWAYS, ("res_init: res__tbl: 0x%lx", res__tbl)); NdisZeroMemory (res__tbl, sizeof(RES) * MAX_RES); // NdisAllocateSpinLock(&res__lock); return(RES_E_SUCC); }