示例#1
0
文件: kMain.c 项目: jcowgill/chaff
void INIT NORETURN kMain(unsigned int mBootCode, multiboot_info_t * mBootInfo)
{
	//Kernel C Entry Point
	// Check boot code
	if(mBootCode != MULTIBOOT_BOOTLOADER_MAGIC)
	{
		Panic("kMain: OS must be loaded by a multiboot bootloader");
	}

	// Wipe screen
	MemSet((void *) 0xC00B8000, 0, 0xFA0);

	// Core Initialization (most other stuff depends on this)
	IntrInit();
	CpuInit();
	MemManagerInit(mBootInfo);
	MemSlabInit();

	// Other Initializations
	CpuInitLate();
	TimerInit();
	ProcInit();
	IoBlockCacheInit();
	IoDevFsInit();

	// Exit boot mode
	MemFreeInitPages();
	ProcIntSelfExit();
}
示例#2
0
/**
 * Attach and bring up controller
 *
 * Allocate controller related resources
 *
 * @param [in] ctrlr controller instance
 */
VMK_ReturnStatus
NvmeCtrlr_Attach(struct NvmeCtrlr *ctrlr)
{
   VMK_ReturnStatus vmkStatus;
   char lockName[VMK_MISC_NAME_MAX];

   /**
    * Set initial state.
    *
    * Note: lock is not initialized by here, so do not use locking.
    */
   NvmeState_SetCtrlrState(ctrlr, NVME_CTRLR_STATE_INIT, VMK_FALSE);

   /**
    * Initialize PCI resources first to access controller bars.
    *
    * Note: has to initialize PCI resource first, all the following operations
    *       require BARs to be mapped already.
    */
   vmkStatus = PciInit(ctrlr);
   if (vmkStatus != VMK_OK) {
      return vmkStatus;
   }

   vmkStatus = NvmeCtrlr_ValidateParams(ctrlr);
   if (vmkStatus != VMK_OK) {
      goto cleanup_pci;
   }

   /* Initialize DMA facilities (dma engine, sg handle, etc.) */
   vmkStatus = OsLib_DmaInit(&ctrlr->ctrlOsResources);
   if (vmkStatus != VMK_OK) {
      goto cleanup_pci;
   }

   /* Initialize interrupt */
   vmkStatus = IntrInit(ctrlr);
   if (vmkStatus != VMK_OK) {
      goto cleanup_dma;
   }

   /* Initialize lock domain for locks within this controller */
   vmkStatus = OsLib_LockDomainCreate(&ctrlr->ctrlOsResources,
			Nvme_GetCtrlrName(ctrlr));
   if (vmkStatus != VMK_OK) {
      goto cleanup_intr;
   }

   /* Initialize lock */
   vmk_StringFormat(lockName, sizeof(lockName), NULL, "%s-lock",
                    Nvme_GetCtrlrName(ctrlr));
   vmkStatus = OsLib_LockCreate(&ctrlr->ctrlOsResources, NVME_LOCK_RANK_LOW,
      lockName, &ctrlr->lock);
   if (vmkStatus != VMK_OK) {
      goto cleanup_lockdomain;
   }

   /* Initialize task management mutex */
   vmk_StringFormat(lockName, sizeof(lockName), NULL, "%s-mutex",
                    Nvme_GetCtrlrName(ctrlr));
   vmkStatus = OsLib_SemaphoreCreate(lockName, 1, &ctrlr->taskMgmtMutex);
   if (vmkStatus != VMK_OK) {
      goto cleanup_lock;
   }
   vmkStatus = OsLib_TimerQueueCreate(ctrlr);
   if (vmkStatus != VMK_OK) {
      goto cleanup_sema;
   }


#if EXC_HANDLER
  vmkStatus = OsLib_SetupExceptionHandler(ctrlr);
   if (vmkStatus != VMK_OK) {
      EPRINT("The device can not handle exceptions.");
      goto cleanup_timer_queue;
   }
#endif

   /*
    * TODO: Initialize and kick off timers and kernel thread
    */
#if 0
   vmkStatus = NvmeCtrlr_CreateLogWorld(ctrlr);
   if (vmkStatus != VMK_OK) {
      goto cleanup_intr;
   }
#endif

   vmkStatus = CreateScsiUnmapSlab(ctrlr);
   if (vmkStatus != VMK_OK) {
      #if EXC_HANDLER
         goto cleanup_exc_handler;
      #else
         goto cleanup_timer_queue;
      #endif
   }

#if NVME_MUL_COMPL_WORLD
   vmkStatus = OsLib_StartCompletionWorlds(ctrlr);
   if (vmkStatus != VMK_OK) {
      EPRINT("Failed to create completion worlds. vmkStatus: 0x%x.",  \
            vmkStatus);
      goto cleanup_unmap_slab;

   }
#endif

   vmkStatus = NvmeCtrlr_AdminQueueSetup(ctrlr);
   if (vmkStatus != VMK_OK) {
#if NVME_MUL_COMPL_WORLD
      goto cleanup_compl_worlds;
#else
      goto cleanup_unmap_slab;
#endif
   }

   #if NVME_DEBUG_INJECT_ERRORS
      NvmeDebug_ErrorInjectInit(ctrlr->errCounters);
   #endif

   /**
    * Initialize all other essential members
    */
   vmk_ListInit(&ctrlr->nsList);

   return VMK_OK;

#if NVME_MUL_COMPL_WORLD
cleanup_compl_worlds:
   OsLib_EndCompletionWorlds(ctrlr);
#endif

cleanup_unmap_slab:
   vmk_SlabDestroy(ctrlr->scsiUnmapSlabId);


#if EXC_HANDLER
cleanup_exc_handler:
   OsLib_ShutdownExceptionHandler(ctrlr);
#endif

cleanup_timer_queue:
   OsLib_TimerQueueDestroy(ctrlr);


cleanup_sema:
   OsLib_SemaphoreDestroy(&ctrlr->taskMgmtMutex);

cleanup_lock:
   OsLib_LockDestroy(&ctrlr->lock);

cleanup_lockdomain:
   OsLib_LockDomainDestroy(&ctrlr->ctrlOsResources);

cleanup_intr:
   IntrCleanup(ctrlr);

cleanup_dma:
   OsLib_DmaCleanup(&ctrlr->ctrlOsResources);

cleanup_pci:
   PciCleanup(ctrlr);

   NvmeState_SetCtrlrState(ctrlr, NVME_CTRLR_STATE_FAILED, VMK_FALSE);

   DPRINT_CTRLR("failed to attach controller, 0x%x.", vmkStatus);

   return vmkStatus;
}