VOID DeleteHandleTable(PPROVIDER_HANDLE_BLOCK HandleTable) { PPROVIDER_HANDLE_BLOCK Current; PLIST_ENTRY CurrentEntry; CloseAllHandles(HandleTable); CurrentEntry = RemoveHeadList(&HandleTable->Entry); while (CurrentEntry != &HandleTable->Entry) { Current = CONTAINING_RECORD(CurrentEntry, PROVIDER_HANDLE_BLOCK, Entry); HeapFree(GlobalHeap, 0, Current); CurrentEntry = RemoveHeadList(&HandleTable->Entry); } }
static VOID Pkt0FinalizeIrpQueue(PLIST_ENTRY IrpQueue) { PLIST_ENTRY entry; PIRP irp; while (!IsListEmpty(IrpQueue)) { entry = RemoveHeadList(IrpQueue); irp = CONTAINING_RECORD(entry, IRP, Tail.Overlay.ListEntry); Pkt0CompleteIrp(irp, STATUS_PIPE_CLOSING, 0); } }
/* Cancel routine for queued read operations initiated by user-mode daemons. */ void ssh_interceptor_iodevice_cancel_queued_read(PDEVICE_OBJECT device, PIRP irp) { SshInterceptorIoDevice io_dev; PLIST_ENTRY entry, next_entry; LIST_ENTRY cancelled_irps; /* Cancel processing is protected by queue-specific lock, not by the (one and only) system-wide Cancel lock */ IoReleaseCancelSpinLock(irp->CancelIrql); io_dev = SSH_NTDEV_TO_SSHDEV(device); NdisInitializeListHead(&cancelled_irps); SSH_DEBUG(SSH_D_MIDSTART, ("ssh_interceptor_iodevice_cancel_queued_read()")); /* Find and dequeue all canceled IRPs (not just the one given as argument). Complete the IRPs after releasing the spin lock. */ NdisAcquireSpinLock(&io_dev->read_queue_lock); entry = io_dev->read_queue.Flink; while (entry && (entry != &io_dev->read_queue)) { next_entry = entry->Flink; irp = CONTAINING_RECORD(entry, IRP, Tail.Overlay.ListEntry); if (irp->Cancel) { RemoveEntryList(entry); InsertTailList(&cancelled_irps, entry); } entry = next_entry; } NdisReleaseSpinLock(&io_dev->read_queue_lock); while (!IsListEmpty(&cancelled_irps)) { entry = RemoveHeadList(&cancelled_irps); irp = CONTAINING_RECORD(entry, IRP, Tail.Overlay.ListEntry); irp->IoStatus.Status = STATUS_CANCELLED; irp->IoStatus.Information = 0; IoCompleteRequest(irp, IO_NO_INCREMENT); SSH_DEBUG(SSH_D_NICETOKNOW, ("IoCompleteRequest(irp = 0x%p, status = STATUS_CANCELLED)", irp)); }; }
void AdapterStop() { PLIST_ENTRY ListEntry; PDHCP_ADAPTER Adapter; ApiLock(); while( !IsListEmpty( &AdapterList ) ) { ListEntry = (PLIST_ENTRY)RemoveHeadList( &AdapterList ); Adapter = CONTAINING_RECORD( ListEntry, DHCP_ADAPTER, ListEntry ); free( Adapter ); } ApiUnlock(); WSACleanup(); }
__inline SshDeviceBuffer ssh_iodevice_buffer_alloc(SshInterceptorIoDevice io_dev, Boolean reliable) { SshDeviceBuffer buf = NULL; PLIST_ENTRY entry; /* 1. Try to get a SshDeviceBuffer from a free list */ entry = NdisInterlockedRemoveHeadList(&io_dev->free_list, &io_dev->free_list_lock); if (entry) buf = CONTAINING_RECORD(entry, SshDeviceBufferStruct, link); /* 2. If failed and this is a reliable message, try to replace an existing unreliable one */ if ((buf == NULL) && (reliable)) { NdisAcquireSpinLock(&io_dev->output_queue_lock); if (!IsListEmpty(&io_dev->unreliable_output_queue)) { /* We found an existing unreliable message */ entry = RemoveHeadList(&io_dev->unreliable_output_queue); /* We must remove the entry from output_queue too */ buf = CONTAINING_RECORD(entry, SshDeviceBufferStruct, unreliable_list_link); SSH_ASSERT(buf != io_dev->current_read_buf); /* This removes the entry from output_queue */ RemoveEntryList(&(buf->link)); } NdisReleaseSpinLock(&io_dev->output_queue_lock); /* If found, we must delete the old message */ if (buf != NULL) ssh_free(buf->addr); } /* 3. If still failed, try to allocate memory for a new SshDeviceBuffer */ if ((buf == NULL) && (reliable)) { buf = ssh_malloc(sizeof(*buf)); if (buf) { /* This buffer will be deleted after use */ buf->pre_allocated = 0; } } return buf; }
NDIS_STATUS NDIS_API PacketReceiveIndicate(IN NDIS_HANDLE ProtocolBindingContext, IN NDIS_HANDLE MacReceiveContext, IN PVOID HeaderBuffer, IN UINT HeaderBufferSize, IN PVOID LookaheadBuffer, IN UINT LookaheadBufferSize, IN UINT PacketSize) { // upcall on packet arrival POPEN_INSTANCE Open; PLIST_ENTRY PacketListEntry; PNDIS_PACKET pPacket; NDIS_STATUS Status; UINT BytesTransfered = 0; PPACKET_RESERVED pReserved; if (HeaderBufferSize != ETHERNET_HEADER_LENGTH) return NDIS_STATUS_NOT_ACCEPTED; Open = (POPEN_INSTANCE) ProtocolBindingContext; // See if there are any pending reads that we can satisfy NdisAcquireSpinLock(&Open->RcvQSpinLock); // fixed 5.11.97 if (IsListEmpty(&Open->RcvList)) { NdisReleaseSpinLock(&Open->RcvQSpinLock); return NDIS_STATUS_NOT_ACCEPTED; } PacketListEntry = RemoveHeadList(&Open->RcvList); NdisReleaseSpinLock(&Open->RcvQSpinLock); pReserved = CONTAINING_RECORD(PacketListEntry, PACKET_RESERVED, ListElement); pPacket = CONTAINING_RECORD(pReserved, NDIS_PACKET, ProtocolReserved); // Copy the MAC header NdisMoveMemory(RESERVED(pPacket)->lpBuffer, HeaderBuffer, HeaderBufferSize); // Call the Mac to transfer the data portion of the packet NdisTransferData(&Status, Open->AdapterHandle, MacReceiveContext, 0, PacketSize, pPacket, &BytesTransfered); if (Status == NDIS_STATUS_PENDING) return NDIS_STATUS_PENDING; if (Status == NDIS_STATUS_SUCCESS) { PacketTransferDataComplete(Open, pPacket, Status, BytesTransfered); return NDIS_STATUS_SUCCESS; } PacketTransferDataComplete(Open, pPacket, Status, 0); return NDIS_STATUS_SUCCESS; }
// // Dynamic heaps are conceptually the same concept as dynamic buffers, but for descriptors // instead of buffer data. // HRESULT DX12Framework::AllocateVersionedDescriptorHeap(DescriptorHeap** ppHeap) { // // Grab a heap from our lookaside list if possible. // if (!IsListEmpty(&m_DynamicDescriptorHeapListHead)) { LIST_ENTRY* pEntry = RemoveHeadList(&m_DynamicDescriptorHeapListHead); *ppHeap = static_cast<DescriptorHeap*>(pEntry); return S_OK; } // // No available buffers, let's try to allocate a new one. // HRESULT hr; ID3D12DescriptorHeap* pD3DDescriptorHeap = nullptr; D3D12_DESCRIPTOR_HEAP_DESC Desc = {}; Desc.NumDescriptors = DYNAMIC_HEAP_SIZE; Desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV; Desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE; hr = m_pDevice->CreateDescriptorHeap(&Desc, IID_PPV_ARGS(&pD3DDescriptorHeap)); if (FAILED(hr)) { LOG_WARNING("Failed to create D3D12 descriptor heap, hr=0x%.8x", hr); goto cleanup; } DescriptorHeap* pHeap = nullptr; try { pHeap = new DescriptorHeap(); } catch (std::bad_alloc&) { LOG_WARNING("Failed to allocate dynamic descriptor heap"); hr = E_OUTOFMEMORY; goto cleanup; } pHeap->pHeap = pD3DDescriptorHeap; *ppHeap = pHeap; return S_OK; cleanup: SafeRelease(pD3DDescriptorHeap); return hr; }
PLIST_ENTRY IopErrorLogGetEntry( ) /*++ Routine Description: This routine gets the next entry from the head of the error log queue and returns it to the caller. Arguments: None. Return Value: The return value is a pointer to the packet removed, or NULL if there were no packets on the queue. --*/ { KIRQL irql; PLIST_ENTRY listEntry; // // Remove the next packet from the queue, if there is one. // ExAcquireSpinLock( &IopErrorLogLock, &irql ); if (IsListEmpty( &IopErrorLogListHead )) { // // Indicate no more work will be done in the context of this worker // thread and indicate to the caller that no packets were located. // IopErrorLogPortPending = FALSE; listEntry = (PLIST_ENTRY) NULL; } else { // // Remove the next packet from the head of the list. // listEntry = RemoveHeadList( &IopErrorLogListHead ); } ExReleaseSpinLock( &IopErrorLogLock, irql ); return listEntry; }
PQUEUE_ENTRY LibTCPDequeuePacket(PCONNECTION_ENDPOINT Connection) { PLIST_ENTRY Entry; PQUEUE_ENTRY qp = NULL; if (IsListEmpty(&Connection->PacketQueue)) return NULL; Entry = RemoveHeadList(&Connection->PacketQueue); qp = CONTAINING_RECORD(Entry, QUEUE_ENTRY, ListEntry); return qp; }
VOID FASTCALL HistoryDeleteBuffers(PCONSOLE Console) { PLIST_ENTRY CurrentEntry; PHISTORY_BUFFER HistoryBuffer; while (!IsListEmpty(&Console->HistoryBuffers)) { CurrentEntry = RemoveHeadList(&Console->HistoryBuffers); HistoryBuffer = CONTAINING_RECORD(CurrentEntry, HISTORY_BUFFER, ListEntry); HistoryDeleteBuffer(HistoryBuffer); } }
static void HID_Device_processQueue(DEVICE_OBJECT *device) { LIST_ENTRY *entry; IRP *irp; BASE_DEVICE_EXTENSION *ext = device->DeviceExtension; UINT buffer_size = RingBuffer_GetBufferSize(ext->ring_buffer); HID_XFER_PACKET *packet; packet = HeapAlloc(GetProcessHeap(), 0, buffer_size); entry = RemoveHeadList(&ext->irp_queue); while(entry != &ext->irp_queue) { int ptr; irp = CONTAINING_RECORD(entry, IRP, Tail.Overlay.s.ListEntry); ptr = PtrToUlong( irp->Tail.Overlay.OriginalFileObject->FsContext ); RingBuffer_Read(ext->ring_buffer, ptr, packet, &buffer_size); if (buffer_size) { NTSTATUS rc; ULONG out_length; IO_STACK_LOCATION *irpsp = IoGetCurrentIrpStackLocation(irp); packet->reportBuffer = (BYTE *)packet + sizeof(*packet); TRACE_(hid_report)("Processing Request (%i)\n",ptr); rc = copy_packet_into_buffer(packet, irp->AssociatedIrp.SystemBuffer, irpsp->Parameters.Read.Length, &out_length); irp->IoStatus.u.Status = rc; irp->IoStatus.Information = out_length; } else { irp->IoStatus.Information = 0; irp->IoStatus.u.Status = STATUS_UNSUCCESSFUL; } IoCompleteRequest( irp, IO_NO_INCREMENT ); entry = RemoveHeadList(&ext->irp_queue); } HeapFree(GetProcessHeap(), 0, packet); }
void CParaNdisRX::FreeRxDescriptorsFromList() { while (!IsListEmpty(&m_NetReceiveBuffers)) { pRxNetDescriptor pBufferDescriptor = (pRxNetDescriptor)RemoveHeadList(&m_NetReceiveBuffers); ParaNdis_FreeRxBufferDescriptor(m_Context, pBufferDescriptor); } for (UINT i = 0; i < ARRAYSIZE(m_ReservedRxBufferMemory); i++) { if (m_ReservedRxBufferMemory[i].Virtual) { ParaNdis_FreePhysicalMemory(m_Context, &m_ReservedRxBufferMemory[i]); } } }
// 清空监控目录 NTSTATUS FilemonCleanGuardPath(PIO_STACK_LOCATION pStack, PIRP pIrp) { KIRQL irql; PLIST_ENTRY pList = NULL; KeAcquireSpinLock(&FltData.spinkLock, &irql); while(&FltData.listGuard != (pList = RemoveHeadList(&FltData.listGuard))) { PFILEMON_GUARD pGuardPath = NULL; } KeReleaseSpinLock(&FltData.spinkLock, irql); return STATUS_SUCCESS; }
VOID SignalLatch (PCountDownLatch CountDownLatch) { // decrementa o contador interno, desbloqueando todas as threads em espera se este chegar a zero if (CountDownLatch->counter == 0) { } CountDownLatch->counter--; if (CountDownLatch->counter == 0) { while (!IsListEmpty(&CountDownLatch->Waiters)) { PWAIT_BLOCK WaitBlockPtr = CONTAINING_RECORD(RemoveHeadList(&CountDownLatch->Waiters), WAIT_BLOCK, Link); UtActivate(WaitBlockPtr->Thread); } } }
VOID CleanupReads( PDEVICE_EXTENSION pdx, PFILE_OBJECT pfo, NTSTATUS status ) { PIO_STACK_LOCATION ReadStack; PLIST_ENTRY head, next, current; LIST_ENTRY CancelList; PIRP ReadIrp; KIRQL OldIrql; // manually cancel all pending reads that match this file handle InitializeListHead( &CancelList ); KeAcquireSpinLock (&pdx->ReadIrpLock, &OldIrql ); head = &pdx->ReadIrpList; for( next=head->Flink; next != head; ) { ReadIrp = CONTAINING_RECORD( next, IRP, Tail.Overlay.ListEntry ); ReadStack = IoGetCurrentIrpStackLocation( ReadIrp ); // advance next pointer now, as we want to muck with it current = next; next = next->Flink; // skip IRPs that do not match // if pfo == NULL, then don't skip anything if(pfo && pfo != ReadStack->FileObject ) { KdPrint((DRIVERNAME " - Skipping IRP, it belongs to a different handle\n")); continue; } // add it to the cancel list RemoveEntryList( current ); InsertTailList ( &CancelList, current ); } KeReleaseSpinLock( &pdx->ReadIrpLock, OldIrql ); // now complete the IRPs we cancelled while (!IsListEmpty(&CancelList)) { next = RemoveHeadList( &CancelList ); ReadIrp = CONTAINING_RECORD(next, IRP, Tail.Overlay.ListEntry); IoSetCancelRoutine ( ReadIrp, NULL ); IoReleaseRemoveLock( &pdx->RemoveLock, ReadIrp ); CompleteRequest ( ReadIrp, status, 0 ); } }
static VOID VenetFreeTx(PADAPTER a) { LIST_ENTRY *e; PTCB t; /* Free list */ while(!IsListEmpty(&a->tcbFree)) { e = RemoveHeadList(&a->tcbFree); t = CONTAINING_RECORD(e, TCB, list); VenetFree(t, sizeof(ADAPTER)); } /* Busy list. Sanity check, should be empty */ while(!IsListEmpty(&a->tcbBusy)) { e = RemoveHeadList(&a->tcbBusy); t = CONTAINING_RECORD(e, TCB, list); VenetFree(t, sizeof(ADAPTER)); } a->vif.destroy(a->txHandle); a->txHandle = NULL; }
void BleServiceDbUnloadRecord(void) { if (BleDbCtx(loadCount) == 1) { BT_GattUnregisterConnectedEvent(&BleDbCtx(gattHandler)); ATTDB_UnRegisterBondStatus(&BleDbCtx(bondingHandler)); while (!IsListEmpty(&BleDbCtx(servicedbList))) { free_ctrl_buffer(RemoveHeadList(&BleDbCtx(servicedbList))); } } BleDbCtx(loadCount)--; }
void free_lastundo(GEM_WINDOW *gwnd) { UNDO_DEF *undo ; VXIMAGE *vimage ; LIST_ENTRY *entry ; if ( !GWIsWindowValid( gwnd ) ) return ; vimage = (VXIMAGE *) gwnd->Extension ; if ( IsListEmpty( &vimage->UndoListHead ) ) return ; entry = RemoveHeadList( &vimage->UndoListHead ) ; undo = GET_UNDO_DEF_FROM_LIST_ENTRY( entry ) ; FreeUndoBuffer( undo ) ; }
PIRP USBSTOR_RemoveIrp( IN PDEVICE_OBJECT DeviceObject) { KIRQL OldLevel; PFDO_DEVICE_EXTENSION FDODeviceExtension; PLIST_ENTRY Entry; PIRP Irp = NULL; // // get FDO device extension // FDODeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension; // // sanity check // ASSERT(FDODeviceExtension->Common.IsFDO); // // acquire lock // KeAcquireSpinLock(&FDODeviceExtension->IrpListLock, &OldLevel); // // check if list is empty // if (!IsListEmpty(&FDODeviceExtension->IrpListHead)) { // // remove entry // Entry = RemoveHeadList(&FDODeviceExtension->IrpListHead); // // get offset to start of irp // Irp = (PIRP)CONTAINING_RECORD(Entry, IRP, Tail.Overlay.ListEntry); } // // release list lock // KeReleaseSpinLock(&FDODeviceExtension->IrpListLock, OldLevel); // // return result // return Irp; }
NTSTATUS NTAPI ReceiveComplete ( PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID Context ) { PAFD_FCB FCB = (PAFD_FCB)Context; PLIST_ENTRY NextIrpEntry; PIRP NextIrp; PAFD_RECV_INFO RecvReq; PIO_STACK_LOCATION NextIrpSp; UNREFERENCED_PARAMETER(DeviceObject); AFD_DbgPrint(MID_TRACE,("Called\n")); if( !SocketAcquireStateLock( FCB ) ) return STATUS_FILE_CLOSED; ASSERT(FCB->ReceiveIrp.InFlightRequest == Irp); FCB->ReceiveIrp.InFlightRequest = NULL; if( FCB->State == SOCKET_STATE_CLOSED ) { /* Cleanup our IRP queue because the FCB is being destroyed */ while( !IsListEmpty( &FCB->PendingIrpList[FUNCTION_RECV] ) ) { NextIrpEntry = RemoveHeadList(&FCB->PendingIrpList[FUNCTION_RECV]); NextIrp = CONTAINING_RECORD(NextIrpEntry, IRP, Tail.Overlay.ListEntry); NextIrpSp = IoGetCurrentIrpStackLocation(NextIrp); RecvReq = GetLockedData(NextIrp, NextIrpSp); NextIrp->IoStatus.Status = STATUS_FILE_CLOSED; NextIrp->IoStatus.Information = 0; UnlockBuffers(RecvReq->BufferArray, RecvReq->BufferCount, FALSE); if( NextIrp->MdlAddress ) UnlockRequest( NextIrp, IoGetCurrentIrpStackLocation( NextIrp ) ); (void)IoSetCancelRoutine(NextIrp, NULL); IoCompleteRequest( NextIrp, IO_NETWORK_INCREMENT ); } SocketStateUnlock( FCB ); return STATUS_FILE_CLOSED; } else if( FCB->State == SOCKET_STATE_LISTENING ) { AFD_DbgPrint(MIN_TRACE,("!!! LISTENER GOT A RECEIVE COMPLETE !!!\n")); SocketStateUnlock( FCB ); return STATUS_INVALID_PARAMETER; } HandleReceiveComplete( FCB, Irp->IoStatus.Status, Irp->IoStatus.Information ); ReceiveActivity( FCB, NULL ); SocketStateUnlock( FCB ); return STATUS_SUCCESS; }
ULONG ApsFlushLogQueue( VOID ) { PLIST_ENTRY ListEntry; PAPS_LOG_ENTRY LogEntry; ULONG IsLogging; ULONG Length; ULONG Complete; ULONG Count = 0; CHAR Buffer[APS_PAGESIZE]; IsLogging = InterlockedCompareExchange(&ApsLogObject.Flag, 0, 0); if (!IsLogging) { return 0; } EnterCriticalSection(&ApsLogObject.Lock); if (IsListEmpty(&ApsLogObject.ListHead)) { LeaveCriticalSection(&ApsLogObject.Lock); return 0; } // // Hand over queued log entries to QueueListHead // while (IsListEmpty(&ApsLogObject.ListHead) != TRUE) { ListEntry = RemoveHeadList(&ApsLogObject.ListHead); LogEntry = CONTAINING_RECORD(ListEntry, APS_LOG_ENTRY, ListEntry); StringCchPrintfA(Buffer, APS_PAGESIZE, "\r\n%02d:%02d:%02d:%03d %04x %s %s", LogEntry->TimeStamp.wHour, LogEntry->TimeStamp.wMinute, LogEntry->TimeStamp.wSecond, LogEntry->TimeStamp.wMilliseconds, LogEntry->ProcessId, LogLevelString[LogEntry->Level], LogEntry->Text); Length = (ULONG)strlen(Buffer); WriteFile(ApsLogObject.FileObject, Buffer, Length, &Complete, NULL); ApsFree(LogEntry); Count += 1; } ApsLogObject.ListDepth = 0; LeaveCriticalSection(&ApsLogObject.Lock); return Count; }
__declspec(dllexport) BOOL WINAPI QSI_Close(DWORD open_context) { SshInterceptorIoDevice io_dev = (SshInterceptorIoDevice)open_context; /* Validate the context. */ if (io_dev != the_interceptor->ipm_device) return FALSE; /* Decrement the reference count as appropriate. */ if (InterlockedDecrement(&io_dev->stream_interface_refcount) == 0) { /* Indicate that the device is now closed. */ NdisAcquireSpinLock(&io_dev->output_queue_lock); io_dev->open = 0; io_dev->cancel_io = 0; NdisReleaseSpinLock(&io_dev->output_queue_lock); /* Uninitialize the packetizer object */ ssh_interceptor_pktizer_uninit(&io_dev->pktizer); /* Indicate the close status. */ if (io_dev->status_cb) io_dev->status_cb(FALSE, io_dev->cb_context); /* Free any buffers in the output queue. */ while (!IsListEmpty(&io_dev->output_queue)) { SshDeviceBuffer buf; PLIST_ENTRY entry; entry = RemoveHeadList(&io_dev->output_queue); buf = CONTAINING_RECORD(entry, SshDeviceBufferStruct, link); ssh_iodevice_buffer_free(io_dev, buf); }; if (io_dev->current_read_buf) { ssh_iodevice_buffer_free(io_dev, io_dev->current_read_buf); io_dev->current_read_buf = NULL; } } else { SSH_NOTREACHED; } return TRUE; }
ULONG CALLBACK MspLogProcedure( IN PVOID Context ) { PLIST_ENTRY ListEntry; PMSP_LOG_ENTRY LogEntry; ULONG IsLogging; ULONG Length; PCHAR Buffer; ULONG Complete; IsLogging = InterlockedCompareExchange(&MspLogObject.Flag, 0, 0); if (!IsLogging) { return 0; } EnterCriticalSection(&MspLogObject.Lock); if (IsListEmpty(&MspLogObject.ListHead)) { LeaveCriticalSection(&MspLogObject.Lock); return 0; } // // Hand over queued log entries to QueueListHead // Buffer = _alloca(4096); while (IsListEmpty(&MspLogObject.ListHead) != TRUE) { ListEntry = RemoveHeadList(&MspLogObject.ListHead); LogEntry = CONTAINING_RECORD(ListEntry, MSP_LOG_ENTRY, ListEntry); StringCchPrintfA(Buffer, 4096, "\r\n%02d:%02d:%02d:%03d %04x %s %s", LogEntry->TimeStamp.wHour, LogEntry->TimeStamp.wMinute, LogEntry->TimeStamp.wSecond, LogEntry->TimeStamp.wMilliseconds, LogEntry->ProcessId, LogLevelString[LogEntry->Level], LogEntry->Text); Length = (ULONG) strlen(Buffer); WriteFile(MspLogObject.FileObject, Buffer, Length, &Complete, NULL); MspFree(LogEntry); } MspLogObject.ListDepth = 0; LeaveCriticalSection(&MspLogObject.Lock); return 0; }
static NTSTATUS LsapDeregisterLogonProcess(PLSA_API_MSG RequestMsg, PLSAP_LOGON_CONTEXT LogonContext) { TRACE("LsapDeregisterLogonProcess(%p %p)\n", RequestMsg, LogonContext); RemoveHeadList(&LogonContext->Entry); NtClose(LogonContext->ClientProcessHandle); NtClose(LogonContext->ConnectionHandle); RtlFreeHeap(RtlGetProcessHeap(), 0, LogonContext); return STATUS_SUCCESS; }
FmpPacket *FmpGetPacket(FmpChannel *channel) { FmpPacket *pkt = NULL; if (!IsListEmpty(&channel->packet_pool)) { pkt = (FmpPacket *)RemoveHeadList(&channel->packet_pool); } else { kal_trace(BT_TRACE_BLE_PROFILES, FMP_PACKETPOOL_EMPTY); } Report(("[FMP] get packet: %x")); return pkt; }
void CParaNdisRX::PopulateQueue() { LIST_ENTRY TempList; CLockedContext<CNdisSpinLock> autoLock(m_Lock); InitializeListHead(&TempList); while (!IsListEmpty(&m_NetReceiveBuffers)) { pRxNetDescriptor pBufferDescriptor = (pRxNetDescriptor)RemoveHeadList(&m_NetReceiveBuffers); InsertTailList(&TempList, &pBufferDescriptor->listEntry); } m_NetNofReceiveBuffers = 0; while (!IsListEmpty(&TempList)) { pRxNetDescriptor pBufferDescriptor = (pRxNetDescriptor)RemoveHeadList(&TempList); if (AddRxBufferToQueue(pBufferDescriptor)) { InsertTailList(&m_NetReceiveBuffers, &pBufferDescriptor->listEntry); m_NetNofReceiveBuffers++; } else { /* TODO - NetMaxReceiveBuffers should take into account all queues */ DPrintf(0, ("FAILED TO REUSE THE BUFFER!!!!\n")); ParaNdis_FreeRxBufferDescriptor(m_Context, pBufferDescriptor); m_Context->NetMaxReceiveBuffers--; } } m_Reinsert = true; m_VirtQueue.Kick(); }
VOID EventLogFlush(PEVENT_LOG EventLog) { KIRQL Irql; PLIST_ENTRY ListEntry = NULL; PSREQUEST request = NULL; LIST_ENTRY FreeListHead; InitializeListHead(&FreeListHead); KeAcquireSpinLock(&EventLog->EventListLock, &Irql); while (!IsListEmpty(&EventLog->EventListHead)) { ListEntry = RemoveHeadList(&EventLog->EventListHead); request = CONTAINING_RECORD(ListEntry, SREQUEST, ListEntry); InsertHeadList(&FreeListHead, &request->ListEntry); } KeReleaseSpinLock(&EventLog->EventListLock, Irql); while (!IsListEmpty(&FreeListHead)) { ListEntry = RemoveHeadList(&FreeListHead); request = CONTAINING_RECORD(ListEntry, SREQUEST, ListEntry); SRequestDelete(request); } }
VOID FASTCALL PurgeInputBuffer(PCONSOLE Console) { PLIST_ENTRY CurrentEntry; ConsoleInput* Event; while (!IsListEmpty(&Console->InputBuffer.InputEvents)) { CurrentEntry = RemoveHeadList(&Console->InputBuffer.InputEvents); Event = CONTAINING_RECORD(CurrentEntry, ConsoleInput, ListEntry); ConsoleFreeHeap(Event); } CloseHandle(Console->InputBuffer.ActiveEvent); }
void SoraKReleaseTXLock(PQUEUED_RW_LOCK RWLock) { KIRQL Irq; KeAcquireSpinLock(&RWLock->Lock, &Irq); if (RWLock->RWSummary == -1) { RWLock->RWSummary = 0; while(!IsListEmpty(&RWLock->WaitingList)) { PLIST_ENTRY entry = RemoveHeadList(&RWLock->WaitingList); InitializeListHead(entry); PRW_REQ req = CONTAINING_RECORD(entry, RW_REQ, __List); if (req->Type == WrReq) { if (RWLock->RWSummary == 0) { DbgPrint("[UExtK]SoraKReleaseTXLock: wake up TX\n"); req->LockObtained = TRUE; RWLock->RWSummary = -1; break; } else { InsertHeadList(&RWLock->WaitingList, entry); //push back break; } } else //read { if (RWLock->RWSummary >= 0) { req->LockObtained = TRUE; DbgPrint("[UExtK]SoraKReleaseTXLock: wake up RX\n"); RWLock->RWSummary++; } else { InsertHeadList(&RWLock->WaitingList, entry); //push back break; } } } } KeReleaseSpinLock(&RWLock->Lock, Irq); DbgPrint("[UExtK] SoraKReleaseTXLock: RW Summary %d\n", RWLock->RWSummary); }
NTSTATUS NTAPI MmReleasePageMemoryConsumer(ULONG Consumer, PFN_NUMBER Page) { PMM_ALLOCATION_REQUEST Request; PLIST_ENTRY Entry; KIRQL OldIrql; if (Page == 0) { DPRINT1("Tried to release page zero.\n"); KeBugCheck(MEMORY_MANAGEMENT); } KeAcquireSpinLock(&AllocationListLock, &OldIrql); if (MmGetReferenceCountPage(Page) == 1) { (void)InterlockedDecrementUL(&MiMemoryConsumers[Consumer].PagesUsed); if (IsListEmpty(&AllocationListHead) || MmAvailablePages < MiMinimumAvailablePages) { KeReleaseSpinLock(&AllocationListLock, OldIrql); if(Consumer == MC_USER) MmRemoveLRUUserPage(Page); OldIrql = KeAcquireQueuedSpinLock(LockQueuePfnLock); MmDereferencePage(Page); KeReleaseQueuedSpinLock(LockQueuePfnLock, OldIrql); } else { Entry = RemoveHeadList(&AllocationListHead); Request = CONTAINING_RECORD(Entry, MM_ALLOCATION_REQUEST, ListEntry); KeReleaseSpinLock(&AllocationListLock, OldIrql); if(Consumer == MC_USER) MmRemoveLRUUserPage(Page); MiZeroPhysicalPage(Page); Request->Page = Page; KeSetEvent(&Request->Event, IO_NO_INCREMENT, FALSE); } } else { KeReleaseSpinLock(&AllocationListLock, OldIrql); if(Consumer == MC_USER) MmRemoveLRUUserPage(Page); OldIrql = KeAcquireQueuedSpinLock(LockQueuePfnLock); MmDereferencePage(Page); KeReleaseQueuedSpinLock(LockQueuePfnLock, OldIrql); } return(STATUS_SUCCESS); }