int cp_init_fast_crypt() { int i; /* enable thread pool */ if (lock_xchg(&pool_enabled, 1) != 0) return ST_OK; /* initialize resources */ ExInitializeNPagedLookasideList(&pool_req_mem, NULL, NULL, 0, sizeof(req_item), '3_cd', 0); KeInitializeEvent(&pool_signal_event, NotificationEvent, FALSE); InitializeSListHead(&pool_head); /* start worker threads */ for (i = 0; i < dc_cpu_count; i++) { if (start_system_thread(cp_worker_thread, NULL, &pool_threads[i]) != ST_OK) { cp_free_fast_crypt(); return ST_ERR_THREAD; } } return ST_OK; }
/*static*/ int winmm_init(cubeb ** context, char const * context_name) { cubeb * ctx; XASSERT(context); *context = NULL; ctx = calloc(1, sizeof(*ctx)); XASSERT(ctx); ctx->ops = &winmm_ops; ctx->work = _aligned_malloc(sizeof(*ctx->work), MEMORY_ALLOCATION_ALIGNMENT); XASSERT(ctx->work); InitializeSListHead(ctx->work); ctx->event = CreateEvent(NULL, FALSE, FALSE, NULL); if (!ctx->event) { winmm_destroy(ctx); return CUBEB_ERROR; } ctx->thread = (HANDLE) _beginthreadex(NULL, 256 * 1024, winmm_buffer_thread, ctx, STACK_SIZE_PARAM_IS_A_RESERVATION, NULL); if (!ctx->thread) { winmm_destroy(ctx); return CUBEB_ERROR; } SetThreadPriority(ctx->thread, THREAD_PRIORITY_TIME_CRITICAL); InitializeCriticalSection(&ctx->lock); ctx->active_streams = 0; ctx->minimum_latency_ms = calculate_minimum_latency(); *context = ctx; return CUBEB_OK; }
int DeviceServiceEntry(PDEVICE_SERVICE_ENTRY_POINTS pEntryPoints) { char* name; char* path; int i, length; PARALLEL_DEVICE* parallel; name = (char*) pEntryPoints->plugin_data->data[1]; path = (char*) pEntryPoints->plugin_data->data[2]; if (name[0] && path[0]) { parallel = xnew(PARALLEL_DEVICE); parallel->device.type = RDPDR_DTYP_PARALLEL; parallel->device.name = name; parallel->device.IRPRequest = parallel_irp_request; parallel->device.Free = parallel_free; length = strlen(name); parallel->device.data = stream_new(length + 1); for (i = 0; i <= length; i++) stream_write_BYTE(parallel->device.data, name[i] < 0 ? '_' : name[i]); parallel->path = path; parallel->pIrpList = (PSLIST_HEADER) _aligned_malloc(sizeof(SLIST_HEADER), MEMORY_ALLOCATION_ALIGNMENT); InitializeSListHead(parallel->pIrpList); parallel->thread = freerdp_thread_new(); pEntryPoints->RegisterDevice(pEntryPoints->devman, (DEVICE*) parallel); freerdp_thread_start(parallel->thread, parallel_thread_func, parallel); } return 0; }
/// <summary> /// Constructs a new scheduler proxy for a UMS scheduler. /// </summary> /// <param name="pScheduler"> /// The scheduler in question. /// </param> /// <param name="pResourceManager"> /// The resource manager instance. /// </param> /// <param name="policy"> /// A copy of the scheduler's policy /// </param> UMSSchedulerProxy::UMSSchedulerProxy(IScheduler *pScheduler, ResourceManager *pResourceManager, const SchedulerPolicy &policy) : SchedulerProxy(pScheduler, pResourceManager, policy), m_pCompletionList(NULL), m_hCompletionListEvent(NULL), m_hTransferListEvent(NULL), m_pushedBackCount(0), m_refCount(1) { m_hTransferListEvent = CreateEventW(NULL, FALSE, FALSE, NULL); if (m_hTransferListEvent == NULL) throw scheduler_resource_allocation_error(HRESULT_FROM_WIN32(GetLastError())); if (!UMS::CreateUmsCompletionList(&m_pCompletionList)) throw scheduler_resource_allocation_error(HRESULT_FROM_WIN32(GetLastError())); if (!UMS::GetUmsCompletionListEvent(m_pCompletionList, &m_hCompletionListEvent)) throw scheduler_resource_allocation_error(HRESULT_FROM_WIN32(GetLastError())); InitializeSListHead(&m_transferList); (static_cast<IUMSScheduler *>(pScheduler))->SetCompletionList(this); }
int cubeb_init(cubeb ** context, char const * context_name) { cubeb * ctx; assert(context); *context = NULL; ctx = calloc(1, sizeof(*ctx)); assert(ctx); ctx->work = _aligned_malloc(sizeof(*ctx->work), MEMORY_ALLOCATION_ALIGNMENT); assert(ctx->work); InitializeSListHead(ctx->work); ctx->event = CreateEvent(NULL, FALSE, FALSE, NULL); if (!ctx->event) { cubeb_destroy(ctx); return CUBEB_ERROR; } ctx->thread = (HANDLE) _beginthreadex(NULL, 64 * 1024, cubeb_buffer_thread, ctx, 0, NULL); if (!ctx->thread) { cubeb_destroy(ctx); return CUBEB_ERROR; } SetThreadPriority(ctx->thread, THREAD_PRIORITY_TIME_CRITICAL); InitializeCriticalSection(&ctx->lock); ctx->active_streams = 0; *context = ctx; return CUBEB_OK; }
/** * Function description * * @return 0 on success, otherwise a Win32 error code */ UINT printer_register(PDEVICE_SERVICE_ENTRY_POINTS pEntryPoints, rdpPrinter* printer) { char* port; UINT32 Flags; int DriverNameLen; WCHAR* DriverName = NULL; int PrintNameLen; WCHAR* PrintName = NULL; UINT32 CachedFieldsLen; BYTE* CachedPrinterConfigData; PRINTER_DEVICE* printer_dev; UINT error; port = malloc(10); if (!port) { WLog_ERR(TAG, "malloc failed!"); return CHANNEL_RC_NO_MEMORY; } sprintf_s(port, 10, "PRN%d", printer->id); printer_dev = (PRINTER_DEVICE*) calloc(1, sizeof(PRINTER_DEVICE)); if (!printer_dev) { WLog_ERR(TAG, "calloc failed!"); free(port); return CHANNEL_RC_NO_MEMORY; } printer_dev->device.type = RDPDR_DTYP_PRINT; printer_dev->device.name = port; printer_dev->device.IRPRequest = printer_irp_request; printer_dev->device.Free = printer_free; printer_dev->rdpcontext = pEntryPoints->rdpcontext; printer_dev->printer = printer; CachedFieldsLen = 0; CachedPrinterConfigData = NULL; Flags = 0; if (printer->is_default) Flags |= RDPDR_PRINTER_ANNOUNCE_FLAG_DEFAULTPRINTER; DriverNameLen = ConvertToUnicode(CP_UTF8, 0, printer->driver, -1, &DriverName, 0) * 2; PrintNameLen = ConvertToUnicode(CP_UTF8, 0, printer->name, -1, &PrintName, 0) * 2; printer_dev->device.data = Stream_New(NULL, 28 + DriverNameLen + PrintNameLen + CachedFieldsLen); if (!printer_dev->device.data) { WLog_ERR(TAG, "calloc failed!"); error = CHANNEL_RC_NO_MEMORY; free(DriverName); free(PrintName); goto error_out; } Stream_Write_UINT32(printer_dev->device.data, Flags); Stream_Write_UINT32(printer_dev->device.data, 0); /* CodePage, reserved */ Stream_Write_UINT32(printer_dev->device.data, 0); /* PnPNameLen */ Stream_Write_UINT32(printer_dev->device.data, DriverNameLen + 2); Stream_Write_UINT32(printer_dev->device.data, PrintNameLen + 2); Stream_Write_UINT32(printer_dev->device.data, CachedFieldsLen); Stream_Write(printer_dev->device.data, DriverName, DriverNameLen); Stream_Write_UINT16(printer_dev->device.data, 0); Stream_Write(printer_dev->device.data, PrintName, PrintNameLen); Stream_Write_UINT16(printer_dev->device.data, 0); if (CachedFieldsLen > 0) { Stream_Write(printer_dev->device.data, CachedPrinterConfigData, CachedFieldsLen); } free(DriverName); free(PrintName); printer_dev->pIrpList = (WINPR_PSLIST_HEADER) _aligned_malloc(sizeof( WINPR_SLIST_HEADER), MEMORY_ALLOCATION_ALIGNMENT); if (!printer_dev->pIrpList) { WLog_ERR(TAG, "_aligned_malloc failed!"); error = CHANNEL_RC_NO_MEMORY; goto error_out; } InitializeSListHead(printer_dev->pIrpList); if (!(printer_dev->event = CreateEvent(NULL, TRUE, FALSE, NULL))) { WLog_ERR(TAG, "CreateEvent failed!"); error = ERROR_INTERNAL_ERROR; goto error_out; } if (!(printer_dev->stopEvent = CreateEvent(NULL, TRUE, FALSE, NULL))) { WLog_ERR(TAG, "CreateEvent failed!"); error = ERROR_INTERNAL_ERROR; goto error_out; } if ((error = pEntryPoints->RegisterDevice(pEntryPoints->devman, (DEVICE*) printer_dev))) { WLog_ERR(TAG, "RegisterDevice failed with error %d!", error); goto error_out; } if (!(printer_dev->thread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) printer_thread_func, (void*) printer_dev, 0, NULL))) { WLog_ERR(TAG, "CreateThread failed!"); error = ERROR_INTERNAL_ERROR; goto error_out; } return CHANNEL_RC_OK; error_out: CloseHandle(printer_dev->stopEvent); CloseHandle(printer_dev->event); _aligned_free(printer_dev->pIrpList); Stream_Free(printer_dev->device.data, TRUE); free(printer_dev); free(port); return error; }
void InitializeHttpInputQueue(PHTTP_LISTENER listener) { listener->HttpInputQueue = &IoContextCacheList[MAX_IO_CONTEXT_PROCESSOR_CACHE]; InitializeSListHead(&listener->HttpInputQueue->Header); }
void printer_register(PDEVICE_SERVICE_ENTRY_POINTS pEntryPoints, rdpPrinter* printer) { char* port; UINT32 Flags; int DriverNameLen; WCHAR* DriverName = NULL; int PrintNameLen; WCHAR* PrintName = NULL; UINT32 CachedFieldsLen; BYTE* CachedPrinterConfigData; PRINTER_DEVICE* printer_dev; port = malloc(10); snprintf(port, 10, "PRN%d", printer->id); printer_dev = (PRINTER_DEVICE*) malloc(sizeof(PRINTER_DEVICE)); ZeroMemory(printer_dev, sizeof(PRINTER_DEVICE)); printer_dev->device.type = RDPDR_DTYP_PRINT; printer_dev->device.name = port; printer_dev->device.IRPRequest = printer_irp_request; printer_dev->device.Free = printer_free; printer_dev->printer = printer; CachedFieldsLen = 0; CachedPrinterConfigData = NULL; DEBUG_SVC("Printer %s registered", printer->name); Flags = 0; if (printer->is_default) Flags |= RDPDR_PRINTER_ANNOUNCE_FLAG_DEFAULTPRINTER; DriverNameLen = ConvertToUnicode(CP_UTF8, 0, printer->driver, -1, &DriverName, 0) * 2; PrintNameLen = ConvertToUnicode(CP_UTF8, 0, printer->name, -1, &PrintName, 0) * 2; printer_dev->device.data = stream_new(28 + DriverNameLen + PrintNameLen + CachedFieldsLen); stream_write_UINT32(printer_dev->device.data, Flags); stream_write_UINT32(printer_dev->device.data, 0); /* CodePage, reserved */ stream_write_UINT32(printer_dev->device.data, 0); /* PnPNameLen */ stream_write_UINT32(printer_dev->device.data, DriverNameLen + 2); stream_write_UINT32(printer_dev->device.data, PrintNameLen + 2); stream_write_UINT32(printer_dev->device.data, CachedFieldsLen); stream_write(printer_dev->device.data, DriverName, DriverNameLen); stream_write_UINT16(printer_dev->device.data, 0); stream_write(printer_dev->device.data, PrintName, PrintNameLen); stream_write_UINT16(printer_dev->device.data, 0); if (CachedFieldsLen > 0) { stream_write(printer_dev->device.data, CachedPrinterConfigData, CachedFieldsLen); } free(DriverName); free(PrintName); printer_dev->pIrpList = (PSLIST_HEADER) _aligned_malloc(sizeof(SLIST_HEADER), MEMORY_ALLOCATION_ALIGNMENT); InitializeSListHead(printer_dev->pIrpList); printer_dev->thread = freerdp_thread_new(); pEntryPoints->RegisterDevice(pEntryPoints->devman, (DEVICE*) printer_dev); freerdp_thread_start(printer_dev->thread, printer_thread_func, printer_dev); }
SmallSizeMemoryPool::SmallSizeMemoryPool(DWORD allocSize) : mAllocSize(allocSize) { CRASH_ASSERT(allocSize > MEMORY_ALLOCATION_ALIGNMENT); InitializeSListHead(&mFreeList); }
VOID BtrInitializeLookaside( VOID ) { PBTR_LOOKASIDE Lookaside; if (BtrProfileObject->Attribute.Type == PROFILE_MM_TYPE) { Lookaside = &BtrLookaside[LOOKASIDE_HEAP]; InitializeSListHead(&Lookaside->ListHead); Lookaside->MaximumDepth = 4096; Lookaside->BlockSize = sizeof(PF_HEAP_RECORD); Lookaside->TotalAllocates = 0; Lookaside->AllocateMisses = 0; Lookaside->TotalFrees = 0; Lookaside->FreeMisses = 0; Lookaside = &BtrLookaside[LOOKASIDE_PAGE]; InitializeSListHead(&Lookaside->ListHead); Lookaside->MaximumDepth = 64; Lookaside->BlockSize = sizeof(PF_PAGE_RECORD); Lookaside->TotalAllocates = 0; Lookaside->AllocateMisses = 0; Lookaside->TotalFrees = 0; Lookaside->FreeMisses = 0; Lookaside = &BtrLookaside[LOOKASIDE_HANDLE]; InitializeSListHead(&Lookaside->ListHead); Lookaside->MaximumDepth = 64; Lookaside->BlockSize = sizeof(PF_HANDLE_RECORD); Lookaside->TotalAllocates = 0; Lookaside->AllocateMisses = 0; Lookaside->TotalFrees = 0; Lookaside->FreeMisses = 0; Lookaside = &BtrLookaside[LOOKASIDE_GDI]; InitializeSListHead(&Lookaside->ListHead); Lookaside->MaximumDepth = 64; Lookaside->BlockSize = sizeof(PF_GDI_RECORD); Lookaside->TotalAllocates = 0; Lookaside->AllocateMisses = 0; Lookaside->TotalFrees = 0; Lookaside->FreeMisses = 0; } if (BtrProfileObject->Attribute.Type == PROFILE_IO_TYPE) { Lookaside = &BtrLookaside[LOOKASIDE_IO_IRP]; InitializeSListHead(&Lookaside->ListHead); Lookaside->MaximumDepth = 4096; Lookaside->BlockSize = sizeof(IO_IRP); Lookaside->TotalAllocates = 0; Lookaside->AllocateMisses = 0; Lookaside->TotalFrees = 0; Lookaside->FreeMisses = 0; Lookaside = &BtrLookaside[LOOKASIDE_IO_IRP_TRACK]; InitializeSListHead(&Lookaside->ListHead); Lookaside->MaximumDepth = 4096; Lookaside->BlockSize = sizeof(IO_COMPLETION_PACKET); Lookaside->TotalAllocates = 0; Lookaside->AllocateMisses = 0; Lookaside->TotalFrees = 0; Lookaside->FreeMisses = 0; Lookaside = &BtrLookaside[LOOKASIDE_IO_COMPLETION]; InitializeSListHead(&Lookaside->ListHead); Lookaside->MaximumDepth = 4096; Lookaside->BlockSize = sizeof(IO_COMPLETION_PACKET); Lookaside->TotalAllocates = 0; Lookaside->AllocateMisses = 0; Lookaside->TotalFrees = 0; Lookaside->FreeMisses = 0; } }
ULONG BtrInitializeStack( __in PBTR_PROFILE_OBJECT Object ) { ULONG Status; ULONG Number; ULONG Size; // // Initialize stack record queue and its lookaside // InitializeSListHead(&BtrStackRecordQueue); InitializeSListHead(&BtrStackRecordLookaside); // // Initialize stack page list // BtrInitLock(&BtrStackPageLock); InitializeListHead(&BtrStackPageRetireList); BtrStackPageFree = BtrAllocateStackPage(); if (!BtrStackPageFree) { return S_FALSE; } // // Initialize stack entry table // for(Number = 0; Number < STACK_RECORD_BUCKET; Number += 1) { BtrInitSpinLock(&BtrStackTable.Hash[Number].SpinLock, 100); InitializeListHead(&BtrStackTable.Hash[Number].ListHead); } BtrStackTable.Count = 0; // // Initialize mapping object for stack record file // Size = GetFileSize(Object->StackFileObject, NULL); if (Size < STACK_FILE_INCREMENT) { Status = BtrExtendFileLength(Object->StackFileObject, STACK_FILE_INCREMENT); if (Status != S_OK) { return Status; } SetFilePointer(Object->StackFileObject, 0, NULL, FILE_BEGIN); BtrSharedData->StackFileLength = STACK_FILE_INCREMENT; } BtrSharedData->StackValidLength = 0; RtlZeroMemory(&BtrStackMapping, sizeof(BTR_MAPPING_OBJECT)); BtrStackMapping.Object = CreateFileMapping(Object->StackFileObject, NULL, PAGE_READWRITE, 0, 0, NULL); if (!BtrStackMapping.Object) { return GetLastError(); } BtrStackMapping.FileLength = BtrSharedData->StackFileLength; return S_OK; }
int TestInterlockedSList(int argc, char* argv[]) { ULONG Count; WINPR_PSLIST_ENTRY pFirstEntry; WINPR_PSLIST_ENTRY pListEntry; WINPR_PSLIST_HEADER pListHead; PPROGRAM_ITEM pProgramItem; /* Initialize the list header to a MEMORY_ALLOCATION_ALIGNMENT boundary. */ pListHead = (WINPR_PSLIST_HEADER) _aligned_malloc(sizeof(WINPR_SLIST_HEADER), MEMORY_ALLOCATION_ALIGNMENT); if (!pListHead) { printf("Memory allocation failed.\n"); return -1; } InitializeSListHead(pListHead); /* Insert 10 items into the list. */ for (Count = 1; Count <= 10; Count += 1) { pProgramItem = (PPROGRAM_ITEM) _aligned_malloc(sizeof(PROGRAM_ITEM), MEMORY_ALLOCATION_ALIGNMENT); if (!pProgramItem) { printf("Memory allocation failed.\n"); return -1; } pProgramItem->Signature = Count; pFirstEntry = InterlockedPushEntrySList(pListHead, &(pProgramItem->ItemEntry)); } /* Remove 10 items from the list and display the signature. */ for (Count = 10; Count >= 1; Count -= 1) { pListEntry = InterlockedPopEntrySList(pListHead); if (!pListEntry) { printf("List is empty.\n"); return -1; } pProgramItem = (PPROGRAM_ITEM) pListEntry; printf("Signature is %d\n", (int) pProgramItem->Signature); /* * This example assumes that the SLIST_ENTRY structure is the * first member of the structure. If your structure does not * follow this convention, you must compute the starting address * of the structure before calling the free function. */ _aligned_free(pListEntry); } /* Flush the list and verify that the items are gone. */ pListEntry = InterlockedFlushSList(pListHead); pFirstEntry = InterlockedPopEntrySList(pListHead); if (pFirstEntry) { printf("Error: List is not empty.\n"); return -1; } _aligned_free(pListHead); return 0; }
SListImpl::SListImpl() { InitializeSListHead(getDetail(this)); }
/* * InitializeTransferPackets * * Allocate/initialize TRANSFER_PACKETs and related resources. */ NTSTATUS InitializeTransferPackets(PDEVICE_OBJECT Fdo) { PCOMMON_DEVICE_EXTENSION commonExt = Fdo->DeviceExtension; PFUNCTIONAL_DEVICE_EXTENSION fdoExt = Fdo->DeviceExtension; PCLASS_PRIVATE_FDO_DATA fdoData = fdoExt->PrivateFdoData; PSTORAGE_ADAPTER_DESCRIPTOR adapterDesc = commonExt->PartitionZeroExtension->AdapterDescriptor; ULONG hwMaxPages; NTSTATUS status = STATUS_SUCCESS; PAGED_CODE(); /* * Precompute the maximum transfer length */ ASSERT(adapterDesc->MaximumTransferLength); hwMaxPages = adapterDesc->MaximumPhysicalPages ? adapterDesc->MaximumPhysicalPages-1 : 0; fdoData->HwMaxXferLen = MIN(adapterDesc->MaximumTransferLength, hwMaxPages << PAGE_SHIFT); fdoData->HwMaxXferLen = MAX(fdoData->HwMaxXferLen, PAGE_SIZE); fdoData->NumTotalTransferPackets = 0; fdoData->NumFreeTransferPackets = 0; InitializeSListHead(&fdoData->FreeTransferPacketsList); InitializeListHead(&fdoData->AllTransferPacketsList); InitializeListHead(&fdoData->DeferredClientIrpList); /* * Set the packet threshold numbers based on the Windows SKU. */ if (ExVerifySuite(Personal)){ // this is Windows Personal MinWorkingSetTransferPackets = MIN_WORKINGSET_TRANSFER_PACKETS_Consumer; MaxWorkingSetTransferPackets = MAX_WORKINGSET_TRANSFER_PACKETS_Consumer; } else if (ExVerifySuite(Enterprise) || ExVerifySuite(DataCenter)){ // this is Advanced Server or Datacenter MinWorkingSetTransferPackets = MIN_WORKINGSET_TRANSFER_PACKETS_Enterprise; MaxWorkingSetTransferPackets = MAX_WORKINGSET_TRANSFER_PACKETS_Enterprise; } else if (ExVerifySuite(TerminalServer)){ // this is standard Server or Pro with terminal server MinWorkingSetTransferPackets = MIN_WORKINGSET_TRANSFER_PACKETS_Server; MaxWorkingSetTransferPackets = MAX_WORKINGSET_TRANSFER_PACKETS_Server; } else { // this is Professional without terminal server MinWorkingSetTransferPackets = MIN_WORKINGSET_TRANSFER_PACKETS_Consumer; MaxWorkingSetTransferPackets = MAX_WORKINGSET_TRANSFER_PACKETS_Consumer; } fdoData->LocalMinWorkingSetTransferPackets = MinWorkingSetTransferPackets; fdoData->LocalMaxWorkingSetTransferPackets = MaxWorkingSetTransferPackets; /* * Allow class driver to override the settings */ if (commonExt->DriverExtension->WorkingSet != NULL) { PCLASS_WORKING_SET workingSet = commonExt->DriverExtension->WorkingSet; // override only if non-zero if (workingSet->XferPacketsWorkingSetMinimum != 0) { fdoData->LocalMinWorkingSetTransferPackets = workingSet->XferPacketsWorkingSetMinimum; // adjust maximum upwards if needed if (fdoData->LocalMaxWorkingSetTransferPackets < fdoData->LocalMinWorkingSetTransferPackets) { fdoData->LocalMaxWorkingSetTransferPackets = fdoData->LocalMinWorkingSetTransferPackets; } } // override only if non-zero if (workingSet->XferPacketsWorkingSetMaximum != 0) { fdoData->LocalMaxWorkingSetTransferPackets = workingSet->XferPacketsWorkingSetMaximum; // adjust minimum downwards if needed if (fdoData->LocalMinWorkingSetTransferPackets > fdoData->LocalMaxWorkingSetTransferPackets) { fdoData->LocalMinWorkingSetTransferPackets = fdoData->LocalMaxWorkingSetTransferPackets; } } // that's all the adjustments required/allowed } // end working set size special code while (fdoData->NumFreeTransferPackets < MIN_INITIAL_TRANSFER_PACKETS){ PTRANSFER_PACKET pkt = NewTransferPacket(Fdo); if (pkt){ InterlockedIncrement(&fdoData->NumTotalTransferPackets); EnqueueFreeTransferPacket(Fdo, pkt); } else { status = STATUS_INSUFFICIENT_RESOURCES; break; } } fdoData->DbgPeakNumTransferPackets = fdoData->NumTotalTransferPackets; /* * Pre-initialize our SCSI_REQUEST_BLOCK template with all * the constant fields. This will save a little time for each xfer. * NOTE: a CdbLength field of 10 may not always be appropriate */ RtlZeroMemory(&fdoData->SrbTemplate, sizeof(SCSI_REQUEST_BLOCK)); fdoData->SrbTemplate.Length = sizeof(SCSI_REQUEST_BLOCK); fdoData->SrbTemplate.Function = SRB_FUNCTION_EXECUTE_SCSI; fdoData->SrbTemplate.QueueAction = SRB_SIMPLE_TAG_REQUEST; fdoData->SrbTemplate.SenseInfoBufferLength = sizeof(SENSE_DATA); fdoData->SrbTemplate.CdbLength = 10; return status; }
/* * InitializeTransferPackets * * Allocate/initialize TRANSFER_PACKETs and related resources. */ NTSTATUS InitializeTransferPackets(PDEVICE_OBJECT Fdo) { PCOMMON_DEVICE_EXTENSION commonExt = Fdo->DeviceExtension; PFUNCTIONAL_DEVICE_EXTENSION fdoExt = Fdo->DeviceExtension; PCLASS_PRIVATE_FDO_DATA fdoData = fdoExt->PrivateFdoData; PSTORAGE_ADAPTER_DESCRIPTOR adapterDesc = commonExt->PartitionZeroExtension->AdapterDescriptor; ULONG hwMaxPages; NTSTATUS status = STATUS_SUCCESS; PAGED_CODE(); /* * Precompute the maximum transfer length */ ASSERT(adapterDesc->MaximumTransferLength); ASSERT(adapterDesc->MaximumPhysicalPages); hwMaxPages = adapterDesc->MaximumPhysicalPages ? adapterDesc->MaximumPhysicalPages-1 : 0; #if defined(_AMD64_SIMULATOR_) // // The simulator appears to have a problem with large transfers. // if (hwMaxPages > 4) { hwMaxPages = 4; } #endif fdoData->HwMaxXferLen = MIN(adapterDesc->MaximumTransferLength, hwMaxPages << PAGE_SHIFT); fdoData->HwMaxXferLen = MAX(fdoData->HwMaxXferLen, PAGE_SIZE); fdoData->NumTotalTransferPackets = 0; fdoData->NumFreeTransferPackets = 0; InitializeSListHead(&fdoData->FreeTransferPacketsList); InitializeListHead(&fdoData->AllTransferPacketsList); InitializeListHead(&fdoData->DeferredClientIrpList); /* * Set the packet threshold numbers based on the Windows SKU. */ if (ExVerifySuite(Personal)){ // this is Windows Personal MinWorkingSetTransferPackets = MIN_WORKINGSET_TRANSFER_PACKETS_Consumer; MaxWorkingSetTransferPackets = MAX_WORKINGSET_TRANSFER_PACKETS_Consumer; } else if (ExVerifySuite(Enterprise) || ExVerifySuite(DataCenter)){ // this is Advanced Server or Datacenter MinWorkingSetTransferPackets = MIN_WORKINGSET_TRANSFER_PACKETS_Enterprise; MaxWorkingSetTransferPackets = MAX_WORKINGSET_TRANSFER_PACKETS_Enterprise; } else if (ExVerifySuite(TerminalServer)){ // this is standard Server or Pro with terminal server MinWorkingSetTransferPackets = MIN_WORKINGSET_TRANSFER_PACKETS_Server; MaxWorkingSetTransferPackets = MAX_WORKINGSET_TRANSFER_PACKETS_Server; } else { // this is Professional without terminal server MinWorkingSetTransferPackets = MIN_WORKINGSET_TRANSFER_PACKETS_Consumer; MaxWorkingSetTransferPackets = MAX_WORKINGSET_TRANSFER_PACKETS_Consumer; } while (fdoData->NumFreeTransferPackets < MIN_INITIAL_TRANSFER_PACKETS){ PTRANSFER_PACKET pkt = NewTransferPacket(Fdo); if (pkt){ InterlockedIncrement(&fdoData->NumTotalTransferPackets); EnqueueFreeTransferPacket(Fdo, pkt); } else { status = STATUS_INSUFFICIENT_RESOURCES; break; } } fdoData->DbgPeakNumTransferPackets = fdoData->NumTotalTransferPackets; /* * Pre-initialize our SCSI_REQUEST_BLOCK template with all * the constant fields. This will save a little time for each xfer. * NOTE: a CdbLength field of 10 may not always be appropriate */ RtlZeroMemory(&fdoData->SrbTemplate, sizeof(SCSI_REQUEST_BLOCK)); fdoData->SrbTemplate.Length = sizeof(SCSI_REQUEST_BLOCK); fdoData->SrbTemplate.Function = SRB_FUNCTION_EXECUTE_SCSI; fdoData->SrbTemplate.QueueAction = SRB_SIMPLE_TAG_REQUEST; fdoData->SrbTemplate.SenseInfoBufferLength = sizeof(SENSE_DATA); fdoData->SrbTemplate.CdbLength = 10; return status; }
VOID NTAPI INIT_FUNCTION MiInitializeNonPagedPool(VOID) { ULONG i; PFN_COUNT PoolPages; PMMFREE_POOL_ENTRY FreeEntry, FirstEntry; PMMPTE PointerPte; PAGED_CODE(); // // Initialize the pool S-LISTs as well as their maximum count. In general, // we'll allow 8 times the default on a 2GB system, and two times the default // on a 1GB system. // InitializeSListHead(&MiPagedPoolSListHead); InitializeSListHead(&MiNonPagedPoolSListHead); if (MmNumberOfPhysicalPages >= ((2 * _1GB) /PAGE_SIZE)) { MiNonPagedPoolSListMaximum *= 8; MiPagedPoolSListMaximum *= 8; } else if (MmNumberOfPhysicalPages >= (_1GB /PAGE_SIZE)) { MiNonPagedPoolSListMaximum *= 2; MiPagedPoolSListMaximum *= 2; } // // However if debugging options for the pool are enabled, turn off the S-LIST // to reduce the risk of messing things up even more // if (MmProtectFreedNonPagedPool) { MiNonPagedPoolSListMaximum = 0; MiPagedPoolSListMaximum = 0; } // // We keep 4 lists of free pages (4 lists help avoid contention) // for (i = 0; i < MI_MAX_FREE_PAGE_LISTS; i++) { // // Initialize each of them // InitializeListHead(&MmNonPagedPoolFreeListHead[i]); } // // Calculate how many pages the initial nonpaged pool has // PoolPages = (PFN_COUNT)BYTES_TO_PAGES(MmSizeOfNonPagedPoolInBytes); MmNumberOfFreeNonPagedPool = PoolPages; // // Initialize the first free entry // FreeEntry = MmNonPagedPoolStart; FirstEntry = FreeEntry; FreeEntry->Size = PoolPages; FreeEntry->Signature = MM_FREE_POOL_SIGNATURE; FreeEntry->Owner = FirstEntry; // // Insert it into the last list // InsertHeadList(&MmNonPagedPoolFreeListHead[MI_MAX_FREE_PAGE_LISTS - 1], &FreeEntry->List); // // Now create free entries for every single other page // while (PoolPages-- > 1) { // // Link them all back to the original entry // FreeEntry = (PMMFREE_POOL_ENTRY)((ULONG_PTR)FreeEntry + PAGE_SIZE); FreeEntry->Owner = FirstEntry; FreeEntry->Signature = MM_FREE_POOL_SIGNATURE; } // // Validate and remember first allocated pool page // PointerPte = MiAddressToPte(MmNonPagedPoolStart); ASSERT(PointerPte->u.Hard.Valid == 1); MiStartOfInitialPoolFrame = PFN_FROM_PTE(PointerPte); // // Keep track of where initial nonpaged pool ends // MmNonPagedPoolEnd0 = (PVOID)((ULONG_PTR)MmNonPagedPoolStart + MmSizeOfNonPagedPoolInBytes); // // Validate and remember last allocated pool page // PointerPte = MiAddressToPte((PVOID)((ULONG_PTR)MmNonPagedPoolEnd0 - 1)); ASSERT(PointerPte->u.Hard.Valid == 1); MiEndOfInitialPoolFrame = PFN_FROM_PTE(PointerPte); // // Validate the first nonpaged pool expansion page (which is a guard page) // PointerPte = MiAddressToPte(MmNonPagedPoolExpansionStart); ASSERT(PointerPte->u.Hard.Valid == 0); // // Calculate the size of the expansion region alone // MiExpansionPoolPagesInitialCharge = (PFN_COUNT) BYTES_TO_PAGES(MmMaximumNonPagedPoolInBytes - MmSizeOfNonPagedPoolInBytes); // // Remove 2 pages, since there's a guard page on top and on the bottom // MiExpansionPoolPagesInitialCharge -= 2; // // Now initialize the nonpaged pool expansion PTE space. Remember there's a // guard page on top so make sure to skip it. The bottom guard page will be // guaranteed by the fact our size is off by one. // MiInitializeSystemPtes(PointerPte + 1, MiExpansionPoolPagesInitialCharge, NonPagedPoolExpansion); }
rdpRpc* rpc_new(rdpTransport* transport) { rdpRpc* rpc = (rdpRpc*) malloc(sizeof(rdpRpc)); if (rpc != NULL) { ZeroMemory(rpc, sizeof(rdpRpc)); rpc->State = RPC_CLIENT_STATE_INITIAL; rpc->transport = transport; rpc->settings = transport->settings; rpc->send_seq_num = 0; rpc->ntlm = ntlm_new(); rpc->NtlmHttpIn = ntlm_http_new(); rpc->NtlmHttpOut = ntlm_http_new(); rpc_ntlm_http_init_channel(rpc, rpc->NtlmHttpIn, TSG_CHANNEL_IN); rpc_ntlm_http_init_channel(rpc, rpc->NtlmHttpOut, TSG_CHANNEL_OUT); rpc->FragBufferSize = 20; rpc->FragBuffer = (BYTE*) malloc(rpc->FragBufferSize); rpc->StubOffset = 0; rpc->StubBufferSize = 20; rpc->StubLength = 0; rpc->StubFragCount = 0; rpc->StubBuffer = (BYTE*) malloc(rpc->FragBufferSize); rpc->rpc_vers = 5; rpc->rpc_vers_minor = 0; /* little-endian data representation */ rpc->packed_drep[0] = 0x10; rpc->packed_drep[1] = 0x00; rpc->packed_drep[2] = 0x00; rpc->packed_drep[3] = 0x00; rpc->max_xmit_frag = 0x0FF8; rpc->max_recv_frag = 0x0FF8; rpc->pdu = (RPC_PDU*) _aligned_malloc(sizeof(RPC_PDU), MEMORY_ALLOCATION_ALIGNMENT); rpc->SendQueue = (PSLIST_HEADER) _aligned_malloc(sizeof(SLIST_HEADER), MEMORY_ALLOCATION_ALIGNMENT); InitializeSListHead(rpc->SendQueue); rpc->ReceiveQueue = (PSLIST_HEADER) _aligned_malloc(sizeof(SLIST_HEADER), MEMORY_ALLOCATION_ALIGNMENT); InitializeSListHead(rpc->ReceiveQueue); rpc->ReceiveWindow = 0x00010000; rpc->ChannelLifetime = 0x40000000; rpc->ChannelLifetimeSet = 0; rpc->KeepAliveInterval = 300000; rpc->CurrentKeepAliveInterval = rpc->KeepAliveInterval; rpc->CurrentKeepAliveTime = 0; rpc->VirtualConnection = rpc_client_virtual_connection_new(rpc); rpc->VirtualConnectionCookieTable = rpc_virtual_connection_cookie_table_new(rpc); rpc->call_id = 1; rpc_client_new(rpc); rpc->client->SynchronousSend = TRUE; rpc->client->SynchronousReceive = TRUE; } return rpc; }