自学教程：C++ FUNCTION_EXIT函数代码示例

NTSTATUSXenBus_DeviceFileInit(WDFDEVICE device, PWDF_IO_QUEUE_CONFIG queue_config, WDFFILEOBJECT file_object){  NTSTATUS status;  PXENPCI_DEVICE_INTERFACE_DATA xpdid = GetXpdid(file_object);  WDF_IO_QUEUE_CONFIG internal_queue_config;    FUNCTION_ENTER();  xpdid->EvtFileCleanup = XenBus_EvtFileCleanup;    xpdid->EvtFileClose = XenBus_EvtFileClose;  queue_config->EvtIoRead = XenBus_EvtIoRead;  queue_config->EvtIoWrite = XenBus_EvtIoWrite;  // queue_config->EvtIoDeviceControl = XenBus_EvtIoDeviceControl;    InitializeListHead(&xpdid->xenbus.read_list_head);  InitializeListHead(&xpdid->xenbus.watch_list_head);  xpdid->xenbus.len = 0;  WDF_IO_QUEUE_CONFIG_INIT(&internal_queue_config, WdfIoQueueDispatchManual);    status = WdfIoQueueCreate(device, &internal_queue_config, WDF_NO_OBJECT_ATTRIBUTES, &xpdid->xenbus.io_queue);  if (!NT_SUCCESS(status)) {    KdPrint(("Error creating queue 0x%x/n", status));    FUNCTION_EXIT();    return status;  }    FUNCTION_EXIT();    return status;}

static mng_boolmng_read_data_callback (mng_handle mng_h,			mng_ptr buffer,			mng_uint32 bytes_requested,        		mng_uint32 * bytes_read){    FUNCTION_ENTRY();    *bytes_read = 0;    return MNG_FALSE;  guint available_mng_food;  GtkMngView * mng_view = GTK_MNG_VIEW (mng_get_userdata (mng_h));  available_mng_food = mng_view->bytes_to_eat - mng_view->bytes_eaten;  if (available_mng_food > 0 && mng_view->mng_food != NULL)    {      * bytes_read = (mng_uint32) MIN ((mng_uint32) available_mng_food, bytes_requested);      memcpy (buffer, mng_view->mng_food + mng_view->bytes_eaten, * bytes_read);      mng_view->bytes_eaten += * bytes_read;      FUNCTION_EXIT();      return MNG_TRUE;    }  else {      FUNCTION_EXIT();    return MNG_FALSE;  }}

VOIDXenUsb_DeviceCallback(PVOID context, ULONG callback_type, PVOID value) {  PXENUSB_DEVICE_DATA xudd = (PXENUSB_DEVICE_DATA)context;  ULONG state;    FUNCTION_ENTER();  switch (callback_type) {  case XN_DEVICE_CALLBACK_BACKEND_STATE:    state = (ULONG)(ULONG_PTR)value;    if (state == xudd->backend_state) {      FUNCTION_MSG("same state %d/n", state);      FUNCTION_EXIT();    }    FUNCTION_MSG("XenBusState = %d -> %d/n", xudd->backend_state, state);    xudd->backend_state = state;    KeSetEvent(&xudd->backend_event, 0, FALSE);    break;  case XN_DEVICE_CALLBACK_SUSPEND:    FUNCTION_MSG("XN_DEVICE_CALLBACK_SUSPEND");    XenUsb_Disconnect(xudd, TRUE);    break;  case XN_DEVICE_CALLBACK_RESUME:    FUNCTION_MSG("XN_DEVICE_CALLBACK_RESUME");    xudd->device_state = DEVICE_STATE_INITIALISING;    XenUsb_Connect(xudd, TRUE);    // some sort of notify to kick things off?    break;  }  FUNCTION_EXIT();}

static gbooleangtk_mng_view_init_libmng (GtkMngView * mng_view){    FUNCTION_ENTRY();  GtkWidget * widget;  g_return_val_if_fail (IS_GTK_MNG_VIEW (mng_view), FALSE);  if (mng_view->MNG_handle)    mng_cleanup (&mng_view->MNG_handle);  mng_view->MNG_handle = mng_initialize (mng_view,					 mng_malloc_callback,					 mng_free_callback,					 MNG_NULL);  if (mng_view->MNG_handle == MNG_NULL) {      FUNCTION_EXIT();    return FALSE;  }  mng_set_storechunks(mng_view->MNG_handle, MNG_TRUE);  //mng_set_dfltimggamma(mng_view->MNG_handle, 5);  //mng_set_displaygamma(mng_view->MNG_handle, 4);  if (mng_setcb_openstream (mng_view->MNG_handle, mng_open_stream_callback) != MNG_NOERROR ||      mng_setcb_closestream (mng_view->MNG_handle, mng_close_stream_callback) != MNG_NOERROR ||      mng_setcb_readdata (mng_view->MNG_handle, mng_read_data_callback) != MNG_NOERROR ||      mng_setcb_processheader (mng_view->MNG_handle, mng_process_header_callback) != MNG_NOERROR ||      mng_setcb_processmend (mng_view->MNG_handle, mng_process_mend_callback) != MNG_NOERROR ||      mng_setcb_processterm (mng_view->MNG_handle, mng_process_term_callback) != MNG_NOERROR ||      mng_setcb_settimer (mng_view->MNG_handle, mng_set_timer_callback) != MNG_NOERROR ||      mng_setcb_gettickcount (mng_view->MNG_handle, mng_get_tickcount_callback) != MNG_NOERROR ||      mng_setcb_getcanvasline (mng_view->MNG_handle, mng_get_canvas_line_callback) != MNG_NOERROR ||      mng_setcb_getalphaline (mng_view->MNG_handle, mng_get_alpha_line_callback) != MNG_NOERROR ||      mng_setcb_refresh (mng_view->MNG_handle, mng_refresh_callback) != MNG_NOERROR)    {      mng_cleanup (&mng_view->MNG_handle);      FUNCTION_EXIT();      return FALSE;    }      //mng_set_suspensionmode(mng_view->MNG_handle, MNG_TRUE);  mng_set_canvasstyle (mng_view->MNG_handle, MNG_CANVAS_RGB8_A8);  widget = GTK_WIDGET (mng_view);  if (!GTK_WIDGET_REALIZED (widget))    gtk_widget_realize (widget);  mng_set_bgcolor (mng_view->MNG_handle,		   widget->style->bg[GTK_STATE_NORMAL].red,		   widget->style->bg[GTK_STATE_NORMAL].green,		   widget->style->bg[GTK_STATE_NORMAL].blue);  FUNCTION_EXIT();  return TRUE;}

static mng_boolmng_close_stream_callback (mng_handle mng_h){    FUNCTION_ENTRY();    FUNCTION_EXIT();  return MNG_TRUE;}

static gbooleangtk_mng_view_expose (GtkWidget * widget, GdkEventExpose * event){    FUNCTION_ENTRY();  g_return_val_if_fail (IS_GTK_MNG_VIEW (widget), FALSE);  g_return_val_if_fail (event != NULL, FALSE);  if (GTK_WIDGET_REALIZED (widget))    {      GdkRectangle dummy;      GdkRectangle rectangle;      GtkMngView * mng_view;      mng_view = GTK_MNG_VIEW (widget);      dummy.x = dummy.y = 0;      dummy.width = mng_view->width;      dummy.height = mng_view->height;      if (gdk_rectangle_intersect (&dummy, &event->area, &rectangle))        gtk_mng_view_paint (mng_view, &rectangle);      mng_display_resume(mng_view->MNG_handle);    }  FUNCTION_EXIT();  return FALSE;}

static mng_ptrmng_malloc_callback (mng_size_t how_many){    FUNCTION_ENTRY();    FUNCTION_EXIT();  return (mng_ptr) g_new0 (gchar, how_many);}

NDIS_STATUSXenNet_SetInformation(    NDIS_HANDLE adapter_context,    NDIS_OID oid,    PVOID information_buffer,    ULONG information_buffer_length,    PULONG bytes_read,    PULONG bytes_needed) {  NTSTATUS status;  int i;    FUNCTION_ENTER();  for (i = 0; xennet_oids[i].oid && xennet_oids[i].oid != oid; i++);  if (!xennet_oids[i].oid) {    FUNCTION_MSG("Unsupported OID %08x/n", oid);    return NDIS_STATUS_NOT_SUPPORTED;  }  if (information_buffer_length < xennet_oids[i].min_length) {    FUNCTION_MSG("%s Set InformationBufferLength %d < min_length %d/n", xennet_oids[i].oid_name, information_buffer_length, xennet_oids[i].min_length);    *bytes_needed = xennet_oids[i].min_length;    return NDIS_STATUS_BUFFER_TOO_SHORT;  }  if (!xennet_oids[i].set_routine) {    FUNCTION_MSG("%s Set not supported/n", xennet_oids[i].oid_name);    return NDIS_STATUS_NOT_SUPPORTED;  }  FUNCTION_MSG("%s/n", xennet_oids[i].oid_name);  status = xennet_oids[i].set_routine(adapter_context, information_buffer, information_buffer_length, bytes_read, bytes_needed);  FUNCTION_EXIT();  return status;}

/* * This function changes the size of a block of memory that was previously allocated with malloc(). */void * GMM001_realloc (uint32_t size, void * MemPtr){  void * MemPtr1 = NULL;  FUNCTION_ENTRY(GID_GMM001, (uint32_t)GMM001_FUNCTION_ENTRY);/*<<<DD_GMM001_API_3_1>>>*/     if (((uint32_t)MemPtr >= (uint32_t)Heap_Bank1_Start) && ((uint32_t)MemPtr <= ((uint32_t)Heap_Bank1_Start + LENGTH1)))  {	  MemPtr1 = LMM001_realloc(&GMM001_handle0, MemPtr, size);  }/*<<<DD_GMM001_API_3_2>>>*/     else if (((uint32_t)MemPtr >= (uint32_t)Heap_Bank2_Start) && ((uint32_t)MemPtr <= ((uint32_t)Heap_Bank2_Start + LENGTH2)))  { 	  MemPtr1 = LMM001_realloc(&GMM001_handle1, MemPtr, size);  }/*<<<DD_GMM001_API_3_3>>>*/     else if (((uint32_t)MemPtr >= (uint32_t)Heap_Bank3_Start) && ((uint32_t)MemPtr <= ((uint32_t)Heap_Bank3_Start + LENGTH3)))  { 	  MemPtr1 = LMM001_realloc(&GMM001_handle2, MemPtr, size);  }  FUNCTION_EXIT(GID_GMM001, (uint32_t)GMM001_FUNCTION_EXIT);  return MemPtr1;}

GtkMngView *gtk_mng_view_new (void){    FUNCTION_ENTRY();    FUNCTION_EXIT();  return GTK_MNG_VIEW (g_object_new(GTK_MNG_VIEW_TYPE, NULL));}

static VOIDXenNet_ResumeWorkItem(PDEVICE_OBJECT device_object, PVOID context){  struct xennet_info *xi = context;  KIRQL old_irql;    UNREFERENCED_PARAMETER(device_object);    FUNCTION_ENTER();  ASSERT(xi->resume_work_item);  IoFreeWorkItem(xi->resume_work_item);    XenNet_TxResumeStart(xi);  XenNet_RxResumeStart(xi);  XenNet_ConnectBackend(xi);  XenNet_RxResumeEnd(xi);  XenNet_TxResumeEnd(xi);  KeAcquireSpinLock(&xi->resume_lock, &old_irql);  xi->resume_work_item = NULL;  KdPrint((__DRIVER_NAME "     *Setting suspend_resume_state_fdo = %d/n", xi->device_state->suspend_resume_state_pdo));  xi->device_state->suspend_resume_state_fdo = xi->device_state->suspend_resume_state_pdo;  KdPrint((__DRIVER_NAME "     *Notifying event channel %d/n", xi->device_state->pdo_event_channel));  xi->vectors.EvtChn_Notify(xi->vectors.context, xi->device_state->pdo_event_channel);  KeReleaseSpinLock(&xi->resume_lock, old_irql);  FUNCTION_EXIT();}

VOIDXenPci_HighSync(PXENPCI_HIGHSYNC_FUNCTION function0, PXENPCI_HIGHSYNC_FUNCTION functionN, PVOID context){  ULONG ActiveProcessorCount;  ULONG i;  highsync_info_t *highsync_info;  KIRQL old_irql;  UNREFERENCED_PARAMETER(context);  FUNCTION_ENTER();  highsync_info = ExAllocatePoolWithTag(NonPagedPool, sizeof(highsync_info_t), XENPCI_POOL_TAG);  RtlZeroMemory(highsync_info, sizeof(highsync_info_t));  KeInitializeEvent(&highsync_info->highsync_complete_event, SynchronizationEvent, FALSE);  highsync_info->function0 = function0;  highsync_info->functionN = functionN;  highsync_info->context = context;  highsync_info->sync_level = HIGH_LEVEL;#if (NTDDI_VERSION >= NTDDI_WINXP)  ActiveProcessorCount = (ULONG)KeNumberProcessors;#else  ActiveProcessorCount = (ULONG)*KeNumberProcessors;#endif  /* Go to HIGH_LEVEL to prevent any races with Dpc's on the current processor */  KeRaiseIrql(highsync_info->sync_level, &old_irql);  highsync_info->do_spin = TRUE;  for (i = 0; i < ActiveProcessorCount; i++)  {    if (i == 0)      KeInitializeDpc(&highsync_info->dpcs[i], XenPci_HighSyncCallFunction0, highsync_info);    else      KeInitializeDpc(&highsync_info->dpcs[i], XenPci_HighSyncCallFunctionN, highsync_info);    KeSetTargetProcessorDpc(&highsync_info->dpcs[i], (CCHAR)i);    KeSetImportanceDpc(&highsync_info->dpcs[i], HighImportance);    KdPrint((__DRIVER_NAME "     queuing Dpc for CPU %d/n", i));    KeInsertQueueDpc(&highsync_info->dpcs[i], NULL, NULL);  }  KdPrint((__DRIVER_NAME "     All Dpc's queued/n"));  KeMemoryBarrier();  KeLowerIrql(old_irql);  KdPrint((__DRIVER_NAME "     Waiting for highsync_complete_event/n"));  KeWaitForSingleObject(&highsync_info->highsync_complete_event, Executive, KernelMode, FALSE, NULL);#if (NTDDI_VERSION >= NTDDI_WINXP)  KeFlushQueuedDpcs();#else  {    /* just wait 1 second until all DPC's finish - not ideal but it's only for W2K */    LARGE_INTEGER interval;    interval.QuadPart = -1 * 1000 * 1000 * 10; /* 1 second */    KeDelayExecutionThread(KernelMode, FALSE, &interval);  }#endif  ExFreePoolWithTag(highsync_info, XENPCI_POOL_TAG);  FUNCTION_EXIT();}

/* called with urb ring lock held */static VOIDPutRequestsOnRing(PXENUSB_DEVICE_DATA xudd) {  partial_pvurb_t *partial_pvurb;  uint16_t id;  int notify;  FUNCTION_ENTER();  FUNCTION_MSG("IRQL = %d/n", KeGetCurrentIrql());  while ((partial_pvurb = (partial_pvurb_t *)RemoveHeadList((PLIST_ENTRY)&xudd->partial_pvurb_queue)) != (partial_pvurb_t *)&xudd->partial_pvurb_queue) {    FUNCTION_MSG("partial_pvurb = %p/n", partial_pvurb);    /* if this partial_pvurb is cancelling another we don't need to check if the cancelled partial_pvurb is on the ring - that is taken care of in HandleEvent */    id = get_id_from_freelist(xudd->req_id_ss);    if (id == (uint16_t)-1) {      FUNCTION_MSG("no free ring slots/n");      InsertHeadList(&xudd->partial_pvurb_queue, &partial_pvurb->entry);      break;    }    InsertTailList(&xudd->partial_pvurb_ring, &partial_pvurb->entry);    xudd->partial_pvurbs[id] = partial_pvurb;    partial_pvurb->req.id = id;        *RING_GET_REQUEST(&xudd->urb_ring, xudd->urb_ring.req_prod_pvt) = partial_pvurb->req;    xudd->urb_ring.req_prod_pvt++;  }  RING_PUSH_REQUESTS_AND_CHECK_NOTIFY(&xudd->urb_ring, notify);  if (notify) {    FUNCTION_MSG("Notifying/n");    XnNotify(xudd->handle, xudd->event_channel);  }    FUNCTION_EXIT();}

static VOIDXenPci_DoPatchKernel0(PVOID context) {  patch_info_t *pi = context;  ULONG i;  ULONG high_level_tpr;  ULONG patch_position_index = 0;  ULONG potential_patch_position_index = 0;  FUNCTION_ENTER();  high_level_tpr = SaveTpr();  /* we know all the other CPUs are at HIGH_LEVEL so set them all to the same as cpu 0 */  for (i = 1; i < MAX_VIRT_CPUS; i++)    SaveTprProcValue(i, high_level_tpr);  /* we can't use KdPrint while patching as it may involve the TPR while we are patching it */  for (i = 0; i < pi->length; i++) {    if (XenPci_TestAndPatchInstruction((PUCHAR)pi->base + i)) {      patch_positions[patch_position_index++] = (PUCHAR)pi->base + i;    } else if (*(PULONG)((PUCHAR)pi->base + i) == LAPIC_TASKPRI) {      potential_patch_positions[potential_patch_position_index++] = (PUCHAR)pi->base + i;    }  }  for (i = 0; i < patch_position_index; i++)    FUNCTION_MSG("Patch added at %p/n", patch_positions[i]);  for (i = 0; i < potential_patch_position_index; i++)    FUNCTION_MSG("Unpatch TPR address found at %p/n", potential_patch_positions[i]);  FUNCTION_EXIT();}

static VOIDXenBus_EvtFileCleanup(WDFFILEOBJECT file_object){  PXENPCI_DEVICE_INTERFACE_DATA xpdid = GetXpdid(file_object);  PXENPCI_DEVICE_DATA xpdd = GetXpdd(WdfFileObjectGetDevice(file_object));  watch_context_t *watch_context;  KIRQL old_irql;  PCHAR msg;  FUNCTION_ENTER();  KeAcquireSpinLock(&xpdid->lock, &old_irql);  while (!IsListEmpty(&xpdid->xenbus.watch_list_head))  {    watch_context = (watch_context_t *)RemoveHeadList(&xpdid->xenbus.watch_list_head);    KeReleaseSpinLock(&xpdid->lock, old_irql);    msg = XenBus_RemWatch(xpdd, XBT_NIL, watch_context->path, XenPci_IoWatch, watch_context);    if (msg != NULL)    {      KdPrint((__DRIVER_NAME "     Error freeing watch (%s)/n", msg));      XenPci_FreeMem(msg);    }    ExFreePoolWithTag(watch_context, XENPCI_POOL_TAG);    WdfObjectDereference(file_object);    KeAcquireSpinLock(&xpdid->lock, &old_irql);  }  KeReleaseSpinLock(&xpdid->lock, old_irql);    FUNCTION_EXIT();}

static VOIDXenBus_EvtFileClose(WDFFILEOBJECT file_object){  UNREFERENCED_PARAMETER(file_object);  FUNCTION_ENTER();  FUNCTION_EXIT();}

VOIDXenNet_PnPEventNotify(  IN NDIS_HANDLE MiniportAdapterContext,  IN NDIS_DEVICE_PNP_EVENT PnPEvent,  IN PVOID InformationBuffer,  IN ULONG InformationBufferLength  ){  UNREFERENCED_PARAMETER(MiniportAdapterContext);  UNREFERENCED_PARAMETER(PnPEvent);  UNREFERENCED_PARAMETER(InformationBuffer);  UNREFERENCED_PARAMETER(InformationBufferLength);  FUNCTION_ENTER();  switch (PnPEvent)  {  case NdisDevicePnPEventSurpriseRemoved:    KdPrint((__DRIVER_NAME "     NdisDevicePnPEventSurpriseRemoved/n"));    break;  case NdisDevicePnPEventPowerProfileChanged :    KdPrint((__DRIVER_NAME "     NdisDevicePnPEventPowerProfileChanged/n"));    break;  default:    KdPrint((__DRIVER_NAME "     %d/n", PnPEvent));    break;  }  FUNCTION_EXIT();}

static VOIDXenPciPdo_EvtDeviceUsageNotification(WDFDEVICE device, WDF_SPECIAL_FILE_TYPE notification_type, BOOLEAN is_in_notification_path){  PXENPCI_PDO_DEVICE_DATA xppdd = GetXppdd(device);  FUNCTION_ENTER();    FUNCTION_MSG("path = %s/n", xppdd->path);  switch (notification_type)  {  case WdfSpecialFilePaging:    FUNCTION_MSG("notification_type = Paging, flag = %d/n", is_in_notification_path);    break;  case WdfSpecialFileHibernation:    xppdd->hiber_usage_kludge = is_in_notification_path;    FUNCTION_MSG("notification_type = Hibernation, flag = %d/n", is_in_notification_path);    break;  case WdfSpecialFileDump:    FUNCTION_MSG("notification_type = Dump, flag = %d/n", is_in_notification_path);    break;  default:    FUNCTION_MSG("notification_type = %d, flag = %d/n", notification_type, is_in_notification_path);    break;  }  FUNCTION_EXIT();}

VOIDXenUsb_EvtRequestCancelPvUrb(WDFREQUEST request) {  WDFDEVICE device = WdfIoQueueGetDevice(WdfRequestGetIoQueue(request));  PXENUSB_DEVICE_DATA xudd = GetXudd(device);  WDF_REQUEST_PARAMETERS wrp;  partial_pvurb_t *partial_pvurb;  pvurb_t *pvurb;  KIRQL old_irql;  FUNCTION_ENTER();  FUNCTION_MSG("cancelling request %p/n", request);  WDF_REQUEST_PARAMETERS_INIT(&wrp);  KeAcquireSpinLock(&xudd->urb_ring_lock, &old_irql);  WdfRequestGetParameters(request, &wrp);  pvurb = (pvurb_t *)wrp.Parameters.Others.Arg1;  FUNCTION_MSG("pvurb = %p/n", pvurb);  ASSERT(pvurb);  partial_pvurb = (partial_pvurb_t *)xudd->partial_pvurb_queue.Flink;  while (partial_pvurb != (partial_pvurb_t *)&xudd->partial_pvurb_queue) {    partial_pvurb_t *next_partial_pvurb = (partial_pvurb_t *)partial_pvurb->entry.Flink;    ASSERT(!partial_pvurb->on_ring);    FUNCTION_MSG("partial_pvurb = %p is not yet on ring/n", partial_pvurb);    RemoveEntryList(&partial_pvurb->entry);    ExFreePoolWithTag(partial_pvurb, XENUSB_POOL_TAG);    pvurb->ref--;    partial_pvurb = next_partial_pvurb;  }  partial_pvurb = (partial_pvurb_t *)xudd->partial_pvurb_ring.Flink;  while (partial_pvurb != (partial_pvurb_t *)&xudd->partial_pvurb_ring) {    partial_pvurb_t *next_partial_pvurb = (partial_pvurb_t *)partial_pvurb->entry.Flink;    partial_pvurb_t *partial_pvurb_cancel;    FUNCTION_MSG("partial_pvurb = %p is on ring/n", partial_pvurb);    ASSERT(partial_pvurb->on_ring);    partial_pvurb_cancel = ExAllocatePoolWithTag(NonPagedPool, sizeof(*partial_pvurb_cancel), XENUSB_POOL_TAG); /* todo - use lookaside */    ASSERT(partial_pvurb_cancel); /* what would we do if this failed? */    partial_pvurb_cancel->req = partial_pvurb->req;    partial_pvurb_cancel->req.pipe = usbif_setunlink_pipe(partial_pvurb_cancel->req.pipe);    partial_pvurb_cancel->req.u.unlink.unlink_id = partial_pvurb->req.id;    partial_pvurb_cancel->pvurb = pvurb;    partial_pvurb_cancel->mdl = NULL;    partial_pvurb_cancel->other_partial_pvurb = partial_pvurb;    partial_pvurb->other_partial_pvurb = partial_pvurb_cancel;    partial_pvurb_cancel->on_ring = FALSE;    pvurb->ref++;    InsertHeadList(&xudd->partial_pvurb_queue, &partial_pvurb_cancel->entry);    partial_pvurb = next_partial_pvurb;  }  if (pvurb->ref) {    PutRequestsOnRing(xudd);    KeReleaseSpinLock(&xudd->urb_ring_lock, old_irql);  } else {    KeReleaseSpinLock(&xudd->urb_ring_lock, old_irql);    WdfRequestComplete(request, STATUS_CANCELLED);  }  FUNCTION_EXIT();}

static VOIDXenPci_HighSyncCallFunction0(  PRKDPC Dpc,  PVOID Context,  PVOID SystemArgument1,  PVOID SystemArgument2){  highsync_info_t *highsync_info = Context;  ULONG ActiveProcessorCount;  KIRQL old_irql;    UNREFERENCED_PARAMETER(Dpc);  UNREFERENCED_PARAMETER(SystemArgument1);  UNREFERENCED_PARAMETER(SystemArgument2);  FUNCTION_ENTER();#if (NTDDI_VERSION >= NTDDI_WINXP)  ActiveProcessorCount = (ULONG)KeNumberProcessors;#else  ActiveProcessorCount = (ULONG)*KeNumberProcessors;#endif  InterlockedIncrement(&highsync_info->nr_procs_at_dispatch_level);  if (highsync_info->sync_level > DISPATCH_LEVEL)  {    while (highsync_info->nr_procs_at_dispatch_level < (LONG)ActiveProcessorCount)    {      KeStallExecutionProcessor(1);      KeMemoryBarrier();    }  }  _disable(); //__asm cli;    KeRaiseIrql(highsync_info->sync_level, &old_irql);  while (highsync_info->nr_spinning_at_sync_level < (LONG)ActiveProcessorCount - 1)  {    KeStallExecutionProcessor(1);    KeMemoryBarrier();  }  highsync_info->function0(highsync_info->context);  KeLowerIrql(old_irql);  _enable(); //__asm sti;  highsync_info->do_spin = FALSE;  KeMemoryBarrier();    /* wait for all the other processors to complete spinning, just in case it matters */  while (highsync_info->nr_spinning_at_sync_level)  {    KeStallExecutionProcessor(1);    KeMemoryBarrier();  }  InterlockedDecrement(&highsync_info->nr_procs_at_dispatch_level);  /* wait until nr_procs_at_dispatch_level drops to 0 indicating that nothing else requires highsync_info */  while (highsync_info->nr_procs_at_dispatch_level)  {    KeStallExecutionProcessor(1);    KeMemoryBarrier();  }  KeSetEvent(&highsync_info->highsync_complete_event, IO_NO_INCREMENT, FALSE);  FUNCTION_EXIT();}

/**  Function to disable Interrupt *  */void NVIC002_DisableIRQ(const NVIC002_HandleType* Handle){  /*<<<DD_NVIC002_API_3>>>*/  FUNCTION_ENTRY(GID_NVIC002,NVIC002_FUNC_ENTRY);  /* Disable Interrupt */  NVIC_DisableIRQ(Handle->NodeID);  FUNCTION_EXIT(GID_NVIC002,NVIC002_FUNC_EXIT);}

static VOIDXenPci_DoPatchKernelN(PVOID context) {  UNREFERENCED_PARAMETER(context);    FUNCTION_ENTER();  FUNCTION_EXIT();}

/* * The function gets the status of the card whether the card is initialized, * inserted or write protected. */uint8_t SDMMC001_GetStatus(void){  uint8_t  DiskStatus;  FUNCTION_ENTRY(GID_SDMMC001,(uint32_t)SDMMC001_FUNCTION_ENTRY);  DiskStatus  = SDMMC001_Initialize();  FUNCTION_EXIT(GID_SDMMC001, (uint32_t)SDMMC001_FUNCTION_EXIT);  return DiskStatus;}

VOIDXenNet_CancelOidRequest(NDIS_HANDLE adapter_context, PVOID request_id){  UNREFERENCED_PARAMETER(adapter_context);  UNREFERENCED_PARAMETER(request_id);  FUNCTION_ENTER();  FUNCTION_EXIT();}

/* * The function writes the data on the card. */uint32_t SDMMC001_WriteBlock(  const uint8_t *WriteBuf,  uint32_t SectorNumber,  uint8_t SectorCount){  status_t Status ;  uint8_t DiskStatus;  uint32_t Result;  FUNCTION_ENTRY(GID_SDMMC001, (uint32_t)SDMMC001_FUNCTION_ENTRY);  do  {    DiskStatus = SDMMC001_GetStatus ();/*<<<DD_SDMMC001_API_4_1>>>*//* If the card is not initialized */    if ((DiskStatus & SDMMC001_STA_NOINIT) != 0)    {      Result = SDMMC001_RES_NOTRDY;      ERROR(GID_SDMMC001,Result,0,0);      break;    }/* End of "if ((DiskStatus & SDMMC001_STA_NOINIT) != 0)"*//* If the card is read only or write protected *//*<<<DD_SDMMC001_API_4_2>>>*/    if ((DiskStatus & SDMMC001_STA_PROTECT) != 0)    {      Result = SDMMC001_RES_WRPRT;      ERROR(GID_SDMMC001,Result,0,0);      break;    }/* End of "if ((DiskStatus & SDMMC001_STA_PROTECT) != 0)"*//*Check for single block write or multiple block write.*//*<<<DD_SDMMC001_API_4_3>>>*/    if (SectorCount == 1)    {      Status = SDMMC003_CardWriteSingleBlock((uint32_t *)WriteBuf, SectorNumber);    }/*<<<DD_SDMMC001_API_4_4>>>*/    else    {      Status = SDMMC003_CardWriteMultipleBlocks((uint32_t *)WriteBuf,/                                                 SectorNumber, SectorCount );    } /* End of "if (SectorCount == 1)"*//*<<<DD_SDMMC001_API_4_5>>>*/    if (Status == (uint32_t)DAVEApp_SUCCESS)    {      Result = SDMMC001_RES_OK;    }/*<<<DD_SDMMC001_API_4_6>>>*/    else    {      Result = SDMMC001_RES_ERROR;      ERROR(GID_SDMMC001,SDMMC001_SDMMC00x_ERROR,0,0);    } /* End of "if (Status == (uint32_t)DAVEApp_SUCCESS)"*/  } while(0);  FUNCTION_EXIT(GID_SDMMC001, (uint32_t)SDMMC001_FUNCTION_EXIT);  return Result;}

NTSTATUSXenPciPdo_EvtDeviceD0Exit(WDFDEVICE device, WDF_POWER_DEVICE_STATE target_state) {  NTSTATUS status = STATUS_SUCCESS;  PXENPCI_PDO_DEVICE_DATA xppdd = GetXppdd(device);  PXENPCI_DEVICE_DATA xpdd = GetXpdd(xppdd->wdf_device_bus_fdo);  char path[128];    UNREFERENCED_PARAMETER(device);  UNREFERENCED_PARAMETER(target_state);    FUNCTION_ENTER();  FUNCTION_MSG("path = %s/n", xppdd->path);    switch (target_state) {  case WdfPowerDeviceD0:    FUNCTION_MSG("WdfPowerDeviceD1/n");    break;  case WdfPowerDeviceD1:    FUNCTION_MSG("WdfPowerDeviceD1/n");    break;  case WdfPowerDeviceD2:    FUNCTION_MSG("WdfPowerDeviceD2/n");    break;  case WdfPowerDeviceD3:    FUNCTION_MSG("WdfPowerDeviceD3/n");    if (xppdd->hiber_usage_kludge) {      FUNCTION_MSG("(but really WdfPowerDevicePrepareForHibernation)/n");      target_state = WdfPowerDevicePrepareForHibernation;    }    break;  case WdfPowerDeviceD3Final:    FUNCTION_MSG("WdfPowerDeviceD3Final/n");    break;  case WdfPowerDevicePrepareForHibernation:    FUNCTION_MSG("WdfPowerDevicePrepareForHibernation/n");    break;    default:    FUNCTION_MSG("Unknown WdfPowerDevice state %d/n", target_state);    break;    }    if (target_state == WdfPowerDevicePrepareForHibernation)  {    FUNCTION_MSG("not powering down as we are hibernating/n");    // should we set the backend state here so it's correct on resume???  }    /* Remove watch on backend state */  /* even if hibernate */  if (xppdd->device_callback) {    FUNCTION_MSG("Removing watch %s/n", xppdd->device);    RtlStringCbPrintfA(path, ARRAY_SIZE(path), "%s/state", xppdd->backend_path);    XenBus_RemWatch(xpdd, XBT_NIL, path, XenPci_BackendStateCallback, xppdd);  }  FUNCTION_EXIT();    return status;}

static NTSTATUSXenVbd_IoCompletion_START_DEVICE(PDEVICE_OBJECT device, PIRP irp, PVOID context) {  UNREFERENCED_PARAMETER(device);  UNREFERENCED_PARAMETER(irp);  FUNCTION_ENTER();  ExFreePoolWithTag(context, XENVBD_POOL_TAG);  FUNCTION_EXIT();  return STATUS_SUCCESS;}

/*  Function to configure SCU Interrupts based on  user configuration. *  */void NVIC_SCU001_Init(){  FUNCTION_ENTRY(GID_NVIC_SCU001,NVIC_SCU001_FUNC_ENTRY);  NVIC_SetPriority(64, NVIC_EncodePriority(NVIC_GetPriorityGrouping(),63,0));  /* Enable Interrupt */  NVIC_EnableIRQ(64);    FUNCTION_EXIT(GID_NVIC_SCU001,NVIC_SCU001_FUNC_EXIT);}

static VOIDXenVbd_StopRing(PXENVBD_DEVICE_DATA xvdd, BOOLEAN suspend) {  PXENVBD_FILTER_DATA xvfd = (PXENVBD_FILTER_DATA)xvdd->xvfd;  NTSTATUS status;  WDFREQUEST request;  WDF_REQUEST_SEND_OPTIONS send_options;  IO_STACK_LOCATION stack;  SCSI_REQUEST_BLOCK srb;  SRB_IO_CONTROL sic;  FUNCTION_ENTER();    /* send a 'stop' down if we are suspending */  if (suspend) {    status = WdfRequestCreate(WDF_NO_OBJECT_ATTRIBUTES, xvfd->wdf_target, &request);    FUNCTION_MSG("WdfRequestCreate = %08x/n", status);    RtlZeroMemory(&stack, sizeof(IO_STACK_LOCATION));    stack.MajorFunction = IRP_MJ_SCSI;    stack.MinorFunction = IRP_MN_SCSI_CLASS;    stack.Parameters.Scsi.Srb = &srb;    RtlZeroMemory(&srb, SCSI_REQUEST_BLOCK_SIZE);    srb.SrbFlags = SRB_FLAGS_BYPASS_FROZEN_QUEUE | SRB_FLAGS_NO_QUEUE_FREEZE;    srb.Length = SCSI_REQUEST_BLOCK_SIZE;    srb.PathId = 0;    srb.TargetId = 0;    srb.Lun = 0;    srb.OriginalRequest = WdfRequestWdmGetIrp(request);    srb.Function = SRB_FUNCTION_IO_CONTROL;    srb.DataBuffer = &sic;        RtlZeroMemory(&sic, sizeof(SRB_IO_CONTROL));    sic.HeaderLength = sizeof(SRB_IO_CONTROL);    memcpy(sic.Signature, XENVBD_CONTROL_SIG, 8);    sic.Timeout = 60;    sic.ControlCode = XENVBD_CONTROL_STOP;        WdfRequestWdmFormatUsingStackLocation(request, &stack);        WDF_REQUEST_SEND_OPTIONS_INIT(&send_options, WDF_REQUEST_SEND_OPTION_SYNCHRONOUS);    if (!WdfRequestSend(request, xvfd->wdf_target, &send_options)) {      FUNCTION_MSG("Request was _NOT_ sent/n");    }    #if DBG    status = WdfRequestGetStatus(request);    FUNCTION_MSG("Request Status = %08x/n", status);    FUNCTION_MSG("SRB Status = %08x/n", srb.SrbStatus);    #endif    WdfObjectDelete(request);  }    status = XnWriteInt32(xvdd->handle, XN_BASE_FRONTEND, "state", XenbusStateClosing);  FUNCTION_EXIT();}

/**  Function to initialize the NVIC node parameters based on  *  UI configuration. */void NVIC002_Init(void){  /*<<<DD_NVIC002_API_1>>>*/    FUNCTION_ENTRY(GID_NVIC002,NVIC002_FUNC_ENTRY);	  // Set Interrupt Priority for NVIC 5 Node App Instance 0    NVIC_SetPriority(5, NVIC_EncodePriority(NVIC_GetPriorityGrouping(),63,0));     /* Enable Interrupt */  NVIC_EnableIRQ(5);  FUNCTION_EXIT(GID_NVIC002,NVIC002_FUNC_EXIT);}