internal bool MoveNext() { if (!this.movedToFirst) { this.movedToFirst = true; return(this.currentPage != UIntPtr.Zero); } else if (currentPage == tailPage) { return(false); } else { this.currentPage = Next(this.currentPage); VTable.Assert(this.currentPage != UIntPtr.Zero); return(true); } }
private void ReleaseInternal(Thread thread, int threadId) { // Assert preconditions:for spinlock with a rank = DisabledInterrupts and below // interrupts have to be disabled. VTable.Assert(Rank == (int)Ranks.NoRank || Rank > (int)Ranks.Dispatcher || Processor.InterruptsDisabled()); // Release spinlock baseLock.Release(threadId + 1); if (thread != null) { // Don't forget to notify thread that it just released spinlock thread.NotifySpinLockReleased(this.baseLock.Type); } }
public ISteamMatchmakingServerListResponse(ServerResponded onServerResponded, ServerFailedToRespond onServerFailedToRespond, RefreshComplete onRefreshComplete) { if (onServerResponded == null || onServerFailedToRespond == null || onRefreshComplete == null) { throw new ArgumentNullException(); } m_ServerResponded = onServerResponded; m_ServerFailedToRespond = onServerFailedToRespond; m_RefreshComplete = onRefreshComplete; m_VTable = new VTable() { m_VTServerResponded = InternalOnServerResponded, m_VTServerFailedToRespond = InternalOnServerFailedToRespond, m_VTRefreshComplete = InternalOnRefreshComplete }; m_pVTable = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(VTable))); Marshal.StructureToPtr(m_VTable, m_pVTable, false); m_pGCHandle = GCHandle.Alloc(m_pVTable, GCHandleType.Pinned); }
internal static unsafe void MarkThreadStack(Thread thread) { int stackVariable; UIntPtr stackBase = PageTable.PagePad(new UIntPtr(&stackVariable)); CallStack.SetStackBase(thread, stackBase); UIntPtr topPageAddr = PageTable.PageAlign(CallStack.StackBase(thread) - 1); SetStackPages(topPageAddr, CallStack.StackBase(thread), thread); UIntPtr regionAddr, regionSize; bool fUsed = MemoryManager.QueryMemory(topPageAddr, out regionAddr, out regionSize); VTable.Assert(fUsed); SetStackPages(regionAddr, topPageAddr, thread); }
public int Compare(Object x, Object y) { VTable.Assert(x is UIntPtr); VTable.Assert(y is UIntPtr); UIntPtr u = (UIntPtr)x; UIntPtr v = (UIntPtr)y; if (u < v) { return(-1); } if (u > v) { return(1); } return(0); }
private static bool AddThread(int index) { Tracing.Log(Tracing.Audit, "AddThread {0} ({1})", (UIntPtr)index, (UIntPtr)threadCount); VTable.Assert(threadCount >= 0); if (Interlocked.Increment(ref threadCount) == 1 && notificationTable != null) { // The thread was started after we started sending out // notifications, so indicate that the thread should not // really be started return(false); } else { return(true); } }
private void AcquireInternal(Thread thread, int threadId) { // Assert preconditions:for spinlock with a rank = DisabledInterrupts and below // interrupts have to be disabled. VTable.Assert(Rank == (int)Ranks.NoRank || Rank > (int)Ranks.Dispatcher || Processor.InterruptsDisabled()); // Thread has to be notified if we are about to acquire spinlock if (thread != null) { thread.NotifySpinLockAboutToAcquire(this.baseLock.Type); } // Get lock baseLock.Acquire(threadId + 1); }
public ISteamMatchmakingPingResponse(ServerResponded onServerResponded, ServerFailedToRespond onServerFailedToRespond) { if ((onServerResponded == null) || (onServerFailedToRespond == null)) { throw new ArgumentNullException(); } this.m_ServerResponded = onServerResponded; this.m_ServerFailedToRespond = onServerFailedToRespond; VTable table = new VTable { m_VTServerResponded = new InternalServerResponded(this.InternalOnServerResponded), m_VTServerFailedToRespond = new InternalServerFailedToRespond(this.InternalOnServerFailedToRespond) }; this.m_VTable = table; this.m_pVTable = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(VTable))); Marshal.StructureToPtr(this.m_VTable, this.m_pVTable, false); this.m_pGCHandle = GCHandle.Alloc(this.m_pVTable, GCHandleType.Pinned); }
private StatusCode Ask(IPv4 dnsServer, Dns.Query [] queries, out Dns.Format answer) { answer = null; Dns.Format outFrame = new Dns.Format(); outFrame.SetFlags(flags); foreach (object o in queries) { outFrame.Queries.Add(o); } byte[] outData = new byte [outFrame.Size]; if (outData.Length > Dns.Format.MaxUdpMessageLength) { return(StatusCode.OverSizeMessage); } int offset = 0; outFrame.Write(outData, ref offset); byte[] rcvData; StatusCode askResponse = AskDnsServer(dnsServer, outData, out rcvData); if (askResponse != StatusCode.Success) { return(askResponse); } VTable.Assert(rcvData != null); try { offset = 0; Dump(rcvData, offset); answer = Dns.Format.Parse(rcvData, ref offset); } catch (Exception e) { DebugPrint("Parser threw {0}", e); return(StatusCode.TransportError); } return(StatusCode.Success); }
private static UIntPtr FindUnusedPages(Thread currentThread, UIntPtr pageCount, PageType newType) { VTable.Deny(PageTable.IsUnusedPageType(newType)); int slot = SlotFromCount(pageCount); Trace.Log(Trace.Area.Page, "FindUnusedPages count={0:x} slot={1}", __arglist(pageCount, slot)); bool iflag = EnterMutex(currentThread); try { while (slot < 32) { UnusedBlockHeader *header = unusedMemoryBlocks[slot].next; while (header != null) { if (header->count >= pageCount) { UIntPtr startPage = PageTable.Page((UIntPtr)header); UIntPtr regionSize = UnlinkUnusedPages(startPage); SetPageTypeClean(startPage, pageCount, newType); if (regionSize > pageCount) { UIntPtr restCount = regionSize - pageCount; UIntPtr endPage = startPage + pageCount; LinkUnusedPages(endPage, restCount, true); } Trace.Log(Trace.Area.Page, "FindUnusedPages success {0:x}", __arglist(startPage)); return(startPage); } header = header->next; } slot++; } return(UIntPtr.Zero); } finally { LeaveMutex(currentThread, iflag); } }
internal override unsafe void Visit(UIntPtr *loc) { // <loc> is a traceable pointer; its referent // either resides in the heap, the stack or in // the static data area. UIntPtr addr = *loc; UIntPtr page = PageTable.Page(addr); VTable.Assert(PageTable.IsMyPage(page), "MemoryAccounting: !IsMyPage"); if (!PageTable.IsGcPage(page)) { PageType pageType = PageTable.Type(page); VTable.Assert(pageType == PageType.NonGC || pageType == PageType.Stack || pageType == PageType.Shared, "unexpected page type"); if (pageType == PageType.NonGC) { // A managed pointer into the static data area. managedPtrsToStaticData++; } else { // A managed pointer into the stack area. managedPtrsToStack++; } return; } UIntPtr objAddr = GC.installedGC.FindObjectAddr(addr); if (objAddr != addr) { // A "truly" interior pointer into a heap object. interiorManagedHeapPtrs++; } else { exteriorManagedHeapPtrs++; } }
internal override void Scan(NonNullReferenceVisitor ptrVisitor, PageType genToCollect) { #if DEBUG_CARDS VTable.DebugPrint("************ Scan to collect generation {0:x8} ******\n", __arglist(genToCollect)); for (UIntPtr i = firstCardNo; i < firstCardNo + totalCards; i++) { if (CardIsDirty(i)) { VTable.DebugPrint("dirty card {0:x8} gen {1:x8}\n", __arglist(i, CardGeneration(i))); } } #endif for (UIntPtr c = firstCardNo; c < firstCardNo + totalCards;) { if (CardIsDirty(c) && IsMyLiveGcCard(c) && CardGeneration(c) > genToCollect) { UIntPtr last = c + 1; while (last < firstCardNo + totalCards && CardIsDirty(last) && IsMyLiveGcCard(last) && CardGeneration(last) > genToCollect) { last++; } #if DEBUG_CARDS VTable.DebugPrint("Scan from {0:x8} to {1:x8} to collect gen {2:x8}\n", __arglist(c, last - 1, genToCollect)); #endif VisitObjectsInCards(ptrVisitor, c, last - 1); c = last; } else { c++; } } #if DEBUG_CARDS VTable.DebugPrint("************ End Scan ******\n"); #endif }
internal unsafe override void Visit(UIntPtr *loc) { UIntPtr addr = *loc; UIntPtr page = PageTable.Page(addr); PageType pageType = PageTable.Type(page); if (!PageTable.IsZombiePage(pageType)) { VTable.Assert(PageTable.IsGcPage(pageType) || PageTable.IsNonGcPage(pageType) || PageTable.IsStackPage(pageType) || PageTable.IsSharedPage(pageType)); return; } UIntPtr objectAddr = InteriorPtrTable.Find(addr); this.threadPtrQueue.Write(objectAddr); this.threadPtrQueue.Write(addr - objectAddr); }
private void SpinToAcquire(int ownerId) { int iSpin; int backoffs = 0; // Assert preconditions: thread's id and passed in id's should be the same VTable.Assert(ownerId != 0); while (true) { // It is assumed this routine is only called after the inline // method has failed the interlocked spinlock test. Therefore we // retry using the safe test only after cheaper, unsafe test // succeeds. for (iSpin = 0; (this.ownerId != 0 && iSpin < MaxSpinLimit); iSpin++) { // Hopefully ownerId will not be enregistered, and this read will // always hit memory, if it does then we are in trouble // Perform HT friendly pause: Thread.NativeNoOp(); } // If we exited the loop prematurely, then try to get the lock if (iSpin < MaxSpinLimit) { // Attempt to grab the spinlock if (TryAcquire(ownerId)) { break; } // If we couldn't get the lock, at least we know someone did, // and the system is making progress; there is no need to // back off. backoffs = 0; continue; } // Increment back off stats backoffs++; } }
private void RunWheel() { tickEvent = new AutoResetEvent(false); SchedulerTime nextTick; TCP tcpSession; while (true) { nextTick = SchedulerTime.Now; nextTick = nextTick.AddMilliseconds(tickFrequency); bool rc = tickEvent.WaitOne(nextTick); VTable.Assert(rc == false); bool done = false; while (done == false) { TimerEvent timerEvent; using (this.objectLock.Lock()) { LinkedList timersList = timerEntries[tickIndex]; VTable.Assert(timersList != null); if (timersList.Count == 0) { tickIndex = (tickIndex + 1) % wheelSize; done = true; break; } LinkedListNode currentNode = timersList.head; VTable.Assert(currentNode != null); timerEvent = currentNode.theObject as TimerEvent; DebugStub.Assert(timerEvent != null); VTable.Assert(timerEvent != null); tcpSession = timerEvent.tcpSession; VTable.Assert(tcpSession != null); } VTable.Assert(timerEvent != null); VTable.Assert(tcpSession != null); timerEvent.timerDelegate.Run(tcpSession); } tickIndex = (tickIndex + 1) % wheelSize; } }
public ISteamMatchmakingRulesResponse(RulesResponded onRulesResponded, RulesFailedToRespond onRulesFailedToRespond, RulesRefreshComplete onRulesRefreshComplete) { if (onRulesResponded == null || onRulesFailedToRespond == null || onRulesRefreshComplete == null) { throw new ArgumentNullException(); } m_RulesResponded = onRulesResponded; m_RulesFailedToRespond = onRulesFailedToRespond; m_RulesRefreshComplete = onRulesRefreshComplete; m_VTable = new VTable { m_VTRulesResponded = InternalOnRulesResponded, m_VTRulesFailedToRespond = InternalOnRulesFailedToRespond, m_VTRulesRefreshComplete = InternalOnRulesRefreshComplete }; m_pVTable = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(VTable))); Marshal.StructureToPtr(m_VTable, m_pVTable, fDeleteOld: false); m_pGCHandle = GCHandle.Alloc(m_pVTable, GCHandleType.Pinned); }
public ISteamMatchmakingPlayersResponse(AddPlayerToList onAddPlayerToList, PlayersFailedToRespond onPlayersFailedToRespond, PlayersRefreshComplete onPlayersRefreshComplete) { if (onAddPlayerToList == null || onPlayersFailedToRespond == null || onPlayersRefreshComplete == null) { throw new ArgumentNullException(); } m_AddPlayerToList = onAddPlayerToList; m_PlayersFailedToRespond = onPlayersFailedToRespond; m_PlayersRefreshComplete = onPlayersRefreshComplete; m_VTable = new VTable { m_VTAddPlayerToList = InternalOnAddPlayerToList, m_VTPlayersFailedToRespond = InternalOnPlayersFailedToRespond, m_VTPlayersRefreshComplete = InternalOnPlayersRefreshComplete }; m_pVTable = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(VTable))); Marshal.StructureToPtr(m_VTable, m_pVTable, fDeleteOld: false); m_pGCHandle = GCHandle.Alloc(m_pVTable, GCHandleType.Pinned); }
internal static unsafe void ClearThreadStack(Thread thread) { short threadIndex = (short)thread.threadIndex; UIntPtr endPage = PageTable.Page(CallStack.StackBase(thread)); UIntPtr startPage = endPage - 1; VTable.Assert(PageTable.IsStackPage(PageTable.Type(startPage))); VTable.Assert(PageTable.Extra(startPage) == threadIndex); while (startPage > 0 && PageTable.IsStackPage(PageTable.Type(startPage - 1)) && PageTable.Extra(startPage - 1) == threadIndex) { startPage--; } UIntPtr startAddr = PageTable.PageAddr(startPage); UIntPtr size = PageTable.RegionSize(endPage - startPage); SetUnallocatedPages(startAddr, size); }
internal static uint PageTableEntry(UIntPtr page) { switch (ptType) { case PTType.CentralPT: case PTType.CentralPTHimem: return(CentralPT.PageTableEntryImpl(page)); #if !SINGULARITY case PTType.FlatDistributedPT: case PTType.FlatDistributedPTTest: return(FlatDistributedPT.PageTableEntryImpl(page)); #endif default: { VTable.NotReached("Unknown PT type: " + ptType); return(0xffffffff); } } }
public ISteamMatchmakingPingResponse(ServerResponded onServerResponded, ServerFailedToRespond onServerFailedToRespond) { if (onServerResponded == null || onServerFailedToRespond == null) { throw new ArgumentNullException(); } m_ServerResponded = onServerResponded; m_ServerFailedToRespond = onServerFailedToRespond; m_VTable = new VTable() { m_VTServerResponded = InternalOnServerResponded, m_VTServerFailedToRespond = InternalOnServerFailedToRespond, }; m_pVTable = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(VTable))); Marshal.StructureToPtr(m_VTable, m_pVTable, false); m_pGCHandle = GCHandle.Alloc(m_pVTable, GCHandleType.Pinned); }
protected override void CompleteWait(Thread ownerThread) { // Assert preconditions VTable.Assert(Thread.CurrentThread == ownerThread); // Update recursion counter this.acquired++; //If this is first time we acquired mutex don't forget to update owner if (this.acquired == 1) { if (this.isKernelObject) { // Kernel thread can't be stop if it owns mutex ownerThread.DelayStop(true); } this.owner = ownerThread; } }
internal unsafe override void Visit(UIntPtr *loc) { UIntPtr addr = *loc; // Ignore pointers out of our memory area if (PageTable.IsForeignAddr(addr)) { return; } UIntPtr page = PageTable.Page(addr); PageType pageType = PageTable.Type(page); if (PageTable.IsGcPage(pageType)) { Object obj = Magic.fromAddress(addr); VTable.Assert(obj.GcMark() != UIntPtr.Zero); VTable.Assert(PageTable.IsMyPage(page)); } }
public void ClearServiceThread(Thread thread) { Tracing.Log(Tracing.Audit, "ClearServiceThread"); if (this != Thread.CurrentThread) { throw new Exception("Only the thread itself may call ClearServiceThread"); } if (notificationTable == null) { return; } if (Interlocked.Exchange(ref notificationTable[threadIndex], null) != null) { // We cleared the notification Interlocked.Increment(ref threadCount); } VTable.Assert(threadCount >= 0); }
internal override unsafe void Visit(UIntPtr *loc) { UIntPtr pageLoc = PageTable.Page((UIntPtr)loc); PageType pageType = PageTable.Type(pageLoc); if (pageType != PageType.NonGC && pageType != PageType.Stack) { VTable.Assert(PageTable.IsGcPage(pageLoc), @"PageTable.IsGcPage(pageLoc)"); return; } if (pageType == PageType.Stack) { *loc = (UIntPtr)((uint)*loc & 0xfffffffc); } }
public ISteamMatchmakingServerListResponse(ServerResponded onServerResponded, ServerFailedToRespond onServerFailedToRespond, RefreshComplete onRefreshComplete) { if (onServerResponded == null || onServerFailedToRespond == null || onRefreshComplete == null) { throw new ArgumentNullException(); } m_ServerResponded = onServerResponded; m_ServerFailedToRespond = onServerFailedToRespond; m_RefreshComplete = onRefreshComplete; m_VTable = new VTable { m_VTServerResponded = new InternalServerResponded(InternalOnServerResponded), m_VTServerFailedToRespond = new InternalServerFailedToRespond(InternalOnServerFailedToRespond), m_VTRefreshComplete = new InternalRefreshComplete(InternalOnRefreshComplete) }; m_pVTable = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(VTable))); Marshal.StructureToPtr(m_VTable, m_pVTable, false); m_pGCHandle = GCHandle.Alloc(m_pVTable, GCHandleType.Pinned); }
//[NoBarriers] void ProcessObjectsSlow(ref ThreadHeaderQueue.LocalList workList) { while (!ConcurrentMSCollector.killCollectorThreads && !workList.IsEmpty()) { // Pop the next value Object obj = workList.Pop(markedColor); if (fVerbose) { VTable.DebugPrint("cms popped: "); VTable.DebugPrint((ulong)Magic.addressOf(obj)); VTable.DebugPrint("\n"); } // let CoCo do some stuff ScanHook(obj); // Visit Fields this.VisitReferenceFields(obj); } }
/* ** Decrement the ref-count on a virtual table object. When the ref-count ** reaches zero, call the xDisconnect() method to delete the object. */ static void sqlite3VtabUnlock(VTable pVTab) { sqlite3 db = pVTab.db; Debug.Assert(db != null); Debug.Assert(pVTab.nRef > 0); Debug.Assert(sqlite3SafetyCheckOk(db)); pVTab.nRef--; if (pVTab.nRef == 0) { object p = pVTab.pVtab; if (p != null) { ((sqlite3_vtab)p).pModule.xDisconnect(ref p); } sqlite3DbFree(db, ref pVTab); } }
internal void ClearFrame(UIntPtr calleeSaveMask, bool framePointerOmitted) { if (!framePointerOmitted) { VTable.Assert((calleeSaveMask & 0x100) == 0, "EBP should not be callee saved"); EBP.ClearFrameReg(); } if ((calleeSaveMask & 0x1) != 0) { EBX.ClearFrameReg(); } if ((calleeSaveMask & 0x80) != 0) { EBP.ClearFrameReg(); } if ((calleeSaveMask & 0x4) != 0) { ESI.ClearFrameReg(); } if ((calleeSaveMask & 0x2) != 0) { EDI.ClearFrameReg(); } if ((calleeSaveMask & 0x8) != 0) { R12.ClearFrameReg(); } if ((calleeSaveMask & 0x10) != 0) { R13.ClearFrameReg(); } if ((calleeSaveMask & 0x20) != 0) { R14.ClearFrameReg(); } if ((calleeSaveMask & 0x40) != 0) { R15.ClearFrameReg(); } }
public static unsafe void Initialize() { maxEntries = 1 << 16; VTable UIntPtrArrayVtable = ((RuntimeType)typeof(UIntPtr[])).classVtable; tableSize = ObjectLayout.ArraySize(UIntPtrArrayVtable, maxEntries); // Allocate a pool for ZCT BumpAllocator entryPool = new BumpAllocator(PageType.NonGC); UIntPtr memStart = MemoryManager.AllocateMemory(tableSize); entryPool.SetZeroedRange(memStart, tableSize); PageManager.SetStaticDataPages(memStart, tableSize); // Initialize ZCT zeroCountTable = (UIntPtr[]) DeferredReferenceCountingCollector. AllocateArray(ref entryPool, UIntPtrArrayVtable, tableSize); VTable.Assert(zeroCountTable != null, @"zeroCountTable != null"); *(uint *)(Magic.addressOf(zeroCountTable) + PostHeader.Size) = maxEntries; VTable.Assert(zeroCountTable.Length == maxEntries, @"zeroCountTable.Length == maxEntries"); // Build ZCT freeEntries list freeHead = 1; for (uint i = 1; i < maxEntries - 1; i++) { zeroCountTable[i] = (UIntPtr)(((i + 1) << 2) | 0x01); } zeroCountTable[maxEntries - 1] = (UIntPtr)0x01; zctGarbagePicker = (ZCTGarbagePicker)BootstrapMemory. Allocate(typeof(ZCTGarbagePicker)); }
internal void ClearFrame(UIntPtr calleeSaveMask, bool framePointerOmitted) { if (!framePointerOmitted) { VTable.Assert((calleeSaveMask & 0x100) == 0, "EBP should not be callee saved"); r11.ClearFrameReg(); } if ((calleeSaveMask & 0x1) != 0) { r4.ClearFrameReg(); } if ((calleeSaveMask & 0x2) != 0) { r5.ClearFrameReg(); } if ((calleeSaveMask & 0x4) != 0) { r6.ClearFrameReg(); } if ((calleeSaveMask & 0x8) != 0) { r7.ClearFrameReg(); } if ((calleeSaveMask & 0x10) != 0) { r8.ClearFrameReg(); } if ((calleeSaveMask & 0x20) != 0) { r9.ClearFrameReg(); } if ((calleeSaveMask & 0x40) != 0) { r10.ClearFrameReg(); } if ((calleeSaveMask & 0x80) != 0) { r11.ClearFrameReg(); } }
internal unsafe static UIntPtr ObjectSize(UIntPtr objectBase, VTable vtable) { uint objectTag = unchecked ((uint)vtable.pointerTrackingMask) & 0xf; switch (objectTag) { case SPARSE_TAG: case DENSE_TAG: { return(ObjectSize(vtable)); } case PTR_VECTOR_TAG: case OTHER_VECTOR_TAG: { uint length = *(uint *)(objectBase + PostHeader.Size); return(ArraySize(vtable, length)); } case PTR_ARRAY_TAG: case OTHER_ARRAY_TAG: { uint length = *(uint *)(objectBase + PostHeader.Size + sizeof(uint)); return(ArraySize(vtable, length)); } case STRING_TAG: { uint length = *(uint *)(objectBase + PostHeader.Size); return(StringSize(vtable, length)); } case RESERVED_TAG: { VTable.Assert(false, "RESERVED_TAG was used!"); return(UIntPtr.Zero); } default: { // escape case return(ObjectSize(vtable)); } } }
public bool GetInterface() { steamFriends = Steamworks.CastInterface<ISteamFriends002> ( steamClient.GetISteamFriends ( user, pipe, "SteamFriends002" ) ); if ( steamFriends == null ) return false; clientFriends = Steamworks.CastInterface<IClientFriends> ( clientEngine.GetIClientFriends ( user, pipe, "CLIENTFRIENDS_INTERFACE_VERSION001" ) ); if ( clientFriends == null ) return false; // Virtual Table VTable vTable = new VTable ( clientFriends.Interface ); getChatMsg = vTable.GetFunc<NativeGetChatRoomEntry> ( 99 ); getChatName = vTable.GetFunc<NativeGetChatRoomName> ( 117 ); sendChatMsg = vTable.GetFunc<NativeSendChatMsg> ( 98 ); CallbackDispatcher.SpawnDispatchThread ( pipe ); return true; }
public ISteamMatchmakingPlayersResponse(AddPlayerToList onAddPlayerToList, PlayersFailedToRespond onPlayersFailedToRespond, PlayersRefreshComplete onPlayersRefreshComplete) { if (onAddPlayerToList == null || onPlayersFailedToRespond == null || onPlayersRefreshComplete == null) { throw new ArgumentNullException(); } m_AddPlayerToList = onAddPlayerToList; m_PlayersFailedToRespond = onPlayersFailedToRespond; m_PlayersRefreshComplete = onPlayersRefreshComplete; m_VTable = new VTable() { m_VTAddPlayerToList = InternalOnAddPlayerToList, m_VTPlayersFailedToRespond = InternalOnPlayersFailedToRespond, m_VTPlayersRefreshComplete = InternalOnPlayersRefreshComplete }; m_pVTable = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(VTable))); Marshal.StructureToPtr(m_VTable, m_pVTable, false); m_pGCHandle = GCHandle.Alloc(m_pVTable, GCHandleType.Pinned); }
public AsioObject(Guid ClassId) { clsid = ClassId; const uint CLSCTX_INPROC_SERVER = 1; Log.Global.WriteLine(MessageType.Info, "AsioObject.AsioObject(ClassId='{0}')", ClassId); int hr = CoCreateInstance(ref ClassId, null, CLSCTX_INPROC_SERVER, ref ClassId, out _this); if (hr != 0) throw new COMException("CoCreateInstance failed", hr); vtbl = new VTable(Marshal.ReadIntPtr(_this)); }
/* ** Invoke a virtual table constructor (either xCreate or xConnect). The ** pointer to the function to invoke is passed as the fourth parameter ** to this procedure. */ static int vtabCallConstructor( sqlite3 db, Table pTab, Module pMod, smdxCreateConnect xConstruct, ref string pzErr ) { VtabCtx sCtx = new VtabCtx(); VTable pVTable; int rc; string[] azArg = pTab.azModuleArg; int nArg = pTab.nModuleArg; string zErr = null; string zModuleName = sqlite3MPrintf( db, "%s", pTab.zName ); //if ( String.IsNullOrEmpty( zModuleName ) ) //{ // return SQLITE_NOMEM; //} pVTable = new VTable();//sqlite3DbMallocZero( db, sizeof( VTable ) ); //if ( null == pVTable ) //{ // sqlite3DbFree( db, ref zModuleName ); // return SQLITE_NOMEM; //} pVTable.db = db; pVTable.pMod = pMod; /* Invoke the virtual table constructor */ //assert( &db->pVtabCtx ); Debug.Assert( xConstruct != null ); sCtx.pTab = pTab; sCtx.pVTable = pVTable; db.pVtabCtx = sCtx; rc = xConstruct( db, pMod.pAux, nArg, azArg, out pVTable.pVtab, out zErr ); db.pVtabCtx = null; //if ( rc == SQLITE_NOMEM ) // db.mallocFailed = 1; if ( SQLITE_OK != rc ) { if ( zErr == "" ) { pzErr = sqlite3MPrintf( db, "vtable constructor failed: %s", zModuleName ); } else { pzErr = sqlite3MPrintf( db, "%s", zErr ); zErr = null;//sqlite3_free( zErr ); } sqlite3DbFree( db, ref pVTable ); } else if ( ALWAYS( pVTable.pVtab ) ) { /* Justification of ALWAYS(): A correct vtab constructor must allocate ** the sqlite3_vtab object if successful. */ pVTable.pVtab.pModule = pMod.pModule; pVTable.nRef = 1; if ( sCtx.pTab != null ) { string zFormat = "vtable constructor did not declare schema: %s"; pzErr = sqlite3MPrintf( db, zFormat, pTab.zName ); sqlite3VtabUnlock( pVTable ); rc = SQLITE_ERROR; } else { int iCol; /* If everything went according to plan, link the new VTable structure ** into the linked list headed by pTab->pVTable. Then loop through the ** columns of the table to see if any of them contain the token "hidden". ** If so, set the Column.isHidden flag and remove the token from ** the type string. */ pVTable.pNext = pTab.pVTable; pTab.pVTable = pVTable; for ( iCol = 0; iCol < pTab.nCol; iCol++ ) { if ( String.IsNullOrEmpty( pTab.aCol[iCol].zType ) ) continue; StringBuilder zType = new StringBuilder( pTab.aCol[iCol].zType); int nType; int i = 0; //if ( zType ) // continue; nType = sqlite3Strlen30( zType ); if ( sqlite3StrNICmp( "hidden", 0, zType.ToString(), 6 ) != 0 || ( zType.Length > 6 && zType[6] != ' ' ) ) { for ( i = 0; i < nType; i++ ) { if ( ( 0 == sqlite3StrNICmp( " hidden", zType.ToString().Substring( i ), 7 ) ) && ( i+7 == zType.Length || (zType[i + 7] == '\0' || zType[i + 7] == ' ' )) ) { i++; break; } } } if ( i < nType ) { int j; int nDel = 6 + ( zType.Length > i + 6 ? 1 : 0 ); for ( j = i; ( j + nDel ) < nType; j++ ) { zType[j] = zType[j + nDel]; } if ( zType[i] == '\0' && i > 0 ) { Debug.Assert( zType[i - 1] == ' ' ); zType.Length = i;//[i - 1] = '\0'; } pTab.aCol[iCol].isHidden = 1; pTab.aCol[iCol].zType = zType.ToString().Substring(0,j); } } } } sqlite3DbFree( db, ref zModuleName ); return rc; }
public bool GetInterface() { steamFriends = Steamworks.CastInterface<ISteamFriends002>( steamClient.GetISteamFriends( user, pipe, "SteamFriends002" ) ); if ( steamFriends == null ) return false; clientFriends = Steamworks.CastInterface<IClientFriends>( clientEngine.GetIClientFriends( user, pipe, "CLIENTFRIENDS_INTERFACE_VERSION001" ) ); if ( clientFriends == null ) return false; VTable vTable = new VTable( clientFriends.Interface ); getChatMsg = vTable.GetFunc<NativeGetChatRoomEntry>( 99 ); getChatName = vTable.GetFunc<NativeGetChatRoomName>( 117 ); groupChatEnabled = true; groupStatusMsg = "Enabled with vtable offsets. (Dangerous)"; CallbackDispatcher.SpawnDispatchThread( pipe ); return true; }
/* ** Lock the virtual table so that it cannot be disconnected. ** Locks nest. Every lock should have a corresponding unlock. ** If an unlock is omitted, resources leaks will occur. ** ** If a disconnect is attempted while a virtual table is locked, ** the disconnect is deferred until all locks have been removed. */ static void sqlite3VtabLock( VTable pVTab ) { pVTab.nRef++; }
/* ** Decrement the ref-count on a virtual table object. When the ref-count ** reaches zero, call the xDisconnect() method to delete the object. */ static void sqlite3VtabUnlock( VTable pVTab ) { sqlite3 db = pVTab.db; Debug.Assert( db != null); Debug.Assert( pVTab.nRef > 0 ); Debug.Assert( sqlite3SafetyCheckOk( db ) ); pVTab.nRef--; if ( pVTab.nRef == 0 ) { object p = pVTab.pVtab; if ( p != null ) { ((sqlite3_vtab)p).pModule.xDisconnect( ref p ); } sqlite3DbFree( db, ref pVTab ); } }
/* ** If the virtual table pVtab supports the transaction interface ** (xBegin/xRollback/xCommit and optionally xSync) and a transaction is ** not currently open, invoke the xBegin method now. ** ** If the xBegin call is successful, place the sqlite3_vtab pointer ** in the sqlite3.aVTrans array. */ static int sqlite3VtabBegin( sqlite3 db, VTable pVTab ) { int rc = SQLITE_OK; sqlite3_module pModule; /* Special case: If db.aVTrans is NULL and db.nVTrans is greater ** than zero, then this function is being called from within a ** virtual module xSync() callback. It is illegal to write to ** virtual module tables in this case, so return SQLITE_LOCKED. */ if ( sqlite3VtabInSync( db ) ) { return SQLITE_LOCKED; } if ( null == pVTab ) { return SQLITE_OK; } pModule = pVTab.pVtab.pModule; if ( pModule.xBegin != null ) { int i; /* If pVtab is already in the aVTrans array, return early */ for ( i = 0; i < db.nVTrans; i++ ) { if ( db.aVTrans[i] == pVTab ) { return SQLITE_OK; } } /* Invoke the xBegin method. If successful, add the vtab to the ** sqlite3.aVTrans[] array. */ rc = growVTrans( db ); if ( rc == SQLITE_OK ) { rc = pModule.xBegin( pVTab.pVtab ); if ( rc == SQLITE_OK ) { addToVTrans( db, pVTab ); } } } return rc; }
/* ** Add the virtual table pVTab to the array sqlite3.aVTrans[]. Space should ** have already been reserved using growVTrans(). */ static void addToVTrans( sqlite3 db, VTable pVTab ) { /* Add pVtab to the end of sqlite3.aVTrans */ db.aVTrans[db.nVTrans++] = pVTab; sqlite3VtabLock( pVTab ); }
/* ** Add the virtual table pVTab to the array sqlite3.aVTrans[]. */ static int addToVTrans(sqlite3 *db, VTable *pVTab) { const int ARRAY_INCR = 5; /* Grow the sqlite3.aVTrans array if required */ if( (db->nVTrans%ARRAY_INCR)==0 ){ VTable **aVTrans; int nBytes = sizeof(sqlite3_vtab *) * (db->nVTrans + ARRAY_INCR); aVTrans = sqlite3DbRealloc(db, (void *)db->aVTrans, nBytes); if( !aVTrans ){ return SQLITE_NOMEM; } memset(&aVTrans[db->nVTrans], 0, sizeof(sqlite3_vtab *)*ARRAY_INCR); db->aVTrans = aVTrans; } /* Add pVtab to the end of sqlite3.aVTrans */ db->aVTrans[db->nVTrans++] = pVTab; sqlite3VtabLock(pVTab); return SQLITE_OK; }
//VTable static int sqlite3VdbeAddOp4( Vdbe p, int op, int p1, int p2, int p3, VTable pP4, int p4type ) { Debug.Assert( pP4 != null ); union_p4 _p4 = new union_p4(); _p4.pVtab = pP4; int addr = sqlite3VdbeAddOp3( p, op, p1, p2, p3 ); sqlite3VdbeChangeP4( p, addr, _p4, p4type ); return addr; }
public bool GetInterface() { steamFriends = Steamworks.CastInterface<ISteamFriends002>(steamClient.GetISteamFriends(user, pipe, steamFriendsEngineVersion)); if (steamFriends == null) return false; Program.logToWindow("Got ISteamFriends002 interface"); clientFriends = Steamworks.CastInterface<IClientFriends>(clientEngine.GetIClientFriends(user, pipe, clientFriendsEngineVersion)); if (clientFriends == null) return false; Program.logToWindow("Got IClientFriends interface"); VTable vTable = new VTable(clientFriends.Interface); getChatMsg = vTable.GetFunc<NativeGetChatRoomEntry>(99); getChatName = vTable.GetFunc<NativeGetChatRoomName>(117); sendChatMsg = vTable.GetFunc<NativeSendChatMsg>(98); groupChatEnabled = true; groupStatusMsg = "Enabled with vTable offsets"; CallbackDispatcher.SpawnDispatchThread(pipe); Program.logToWindow("Found steam interface. Listing current clans:"); int numClans = steamFriends.GetClanCount(); for (int i = 0; i < numClans; i++) { ulong clanId = steamFriends.GetClanByIndex(i); Program.logToWindow("Clan Num: " + i + " ID: " + clanId + " Name: " + steamFriends.GetClanName(clanId)); } return true; }
public int AddOp4(OP op, int p1, int p2, int p3, VTable p4, Vdbe.P4T p4t) // VTable { Debug.Assert(p4 != null); int addr = AddOp3(op, p1, p2, p3); ChangeP4(p, addr, new P4_t { VTable = p4 }, p4t); return addr; }
private void Dispose(bool Disposing) { if (_this != IntPtr.Zero) { vtbl.Release(_this); _this = IntPtr.Zero; } vtbl = null; }