/* Returns 0 if successful */ static int hook_debug_interrupts( void ) { int i; PACKAGE FarPtr package = NULL; if( my_package_bind( DOS4G_KERNEL_PACKAGE_NAME, DOS4G_DEBUG_HOOK_ENTRY, &package, (ACTION **)&debug_hook ) ) return( 1 ); if( my_package_bind( DOS4G_KERNEL_PACKAGE_NAME, DOS4G_INTCHAIN_ENTRY, &package, (ACTION **)&chain_interrupt ) ) return( 2 ); /* OK to not find this entry point */ my_package_bind( DOS4G_KERNEL_PACKAGE_NAME, DOS4G_NULLP_ENTRY, &package, (ACTION **)&D32NullPtrCheck ); if( D32NullPtrCheck != NULL_PTR ) /* Disable NULLP checking for now */ nullp_checks = D32NullPtrCheck( 0 ); for( i = 0; i < sizeof( hook_exceptions ) / sizeof( hook_exceptions[0] ); i++ ) debug_hook( hook_exceptions[i], 1, debug_handler ); for( i = 0; i < sizeof( hook_interrupts ) / sizeof( hook_interrupts[0] ); i++ ) debug_hook( hook_interrupts[i], 0, debug_handler ); /* Hook the hot key interrupt in protected mode and make it pass up. */ if( _d16info.miscellaneous & D16misc_AT_compat ) { debug_hook( hotkey_int, 1, debug_handler ); debug_hook( hotkey_int, 0, debug_handler ); rsi_int_passup( hotkey_int ); } #ifdef TIMER if( timer_mult != 0 ) { debug_hook( INT_TIMER, 0, debug_handler ); /* Hook as interrupt only */ outp( TIMER0, ( 65536 / timer_mult ) & 0xff ); outp( TIMER0, ( 65536 / timer_mult ) >> 8 ); }
/** * @brief Retrieve the data associated with a managed string. * @param s the input managed string. * @return NULL on failure or for an improperly constructed string; otherwise, a pointer to the string's data. */ void *st_data_get(stringer_t *s) { uint32_t opts; void *result = NULL; if (!s || !(opts = s->opts)) { return NULL; } #ifdef MAGMA_PEDANTIC else if (!st_valid_opts(opts)) { debug_hook(); log_pedantic("Invalid string options. { opt = %u = %s }", opts, st_info_opts(opts, MEMORYBUF(128), 128)); return NULL; } #endif switch (opts & (CONSTANT_T | NULLER_T | BLOCK_T | PLACER_T | MANAGED_T | MAPPED_T)) { case (CONSTANT_T): result = ((constant_t *)s)->data; break; case (NULLER_T): result = ((nuller_t *)s)->data; break; case (BLOCK_T): result = ((block_t *)s)->data; break; case (PLACER_T): result = ((placer_t *)s)->data; break; case (MANAGED_T): result = ((managed_t *)s)->data; break; case (MAPPED_T): result = ((mapped_t *)s)->data; break; } return result; }
EFI_STATUS efi_main(EFI_HANDLE image, EFI_SYSTEM_TABLE *systab) { EFI_STATUS rc; InitializeLib(image, systab); /* * if SHIM_DEBUG is set, wait for a debugger to attach. */ debug_hook(); rc = uefi_call_wrapper(BS->HandleProtocol, 3, image, &LoadedImageProtocol, (void *)&this_image); if (EFI_ERROR(rc)) { Print(L"Error: could not find loaded image: %d\n", rc); return rc; } Print(L"System BootOrder not found. Initializing defaults.\n"); set_boot_order(); rc = find_boot_options(this_image->DeviceHandle); if (EFI_ERROR(rc)) { Print(L"Error: could not find boot options: %d\n", rc); return rc; } try_start_first_option(image); Print(L"Reset System\n"); uefi_call_wrapper(RT->ResetSystem, 4, EfiResetCold, EFI_SUCCESS, 0, NULL); return EFI_SUCCESS; }
EFI_STATUS efi_main(EFI_HANDLE image, EFI_SYSTEM_TABLE *systab) { EFI_STATUS rc; update_table **updates = NULL; UINTN n_updates = 0; EFI_RESET_TYPE reset_type = EfiResetWarm; InitializeLib(image, systab); /* * if SHIM_DEBUG is set, print info for our attached debugger. */ debug_hook(); /* * Basically the workflow here is: * 1) find and validate any update state variables with the right GUID * 2) allocate our capsule data structures and add the capsules * #1 described * 3) update status variables * 4) apply the capsule updates * 5) reboot */ /* * Step 1: find and validate update state variables */ /* XXX TODO: * 1) survey the reset types first, and separate into groups * according to them * 2) if there's more than one, mirror BootCurrent back into BootNext * so we can do multiple runs * 3) only select the ones from one type for the first go */ rc = find_updates(&n_updates, &updates); if (EFI_ERROR(rc)) { Print(L"fwupdate: Could not find updates: %r\n", rc); return rc; } if (n_updates == 0) { Print(L"fwupdate: No updates to process. Called in error?\n"); return EFI_INVALID_PARAMETER; } /* * Step 2: Build our data structure and add the capsules to it. */ EFI_CAPSULE_HEADER *capsules[n_updates + 1]; EFI_CAPSULE_BLOCK_DESCRIPTOR *cbd_data; UINTN i; rc = allocate((void **)&cbd_data, sizeof (EFI_CAPSULE_BLOCK_DESCRIPTOR)*(n_updates+1)); if (EFI_ERROR(rc)) { Print(L"%a:%a():%d: Tried to allocate %d\n", __FILE__, __func__, __LINE__, sizeof (EFI_CAPSULE_BLOCK_DESCRIPTOR)*(n_updates+1)); Print(L"fwupdate: Could not allocate memory: %r.\n",rc); return rc; } for (i = 0; i < n_updates; i++) { rc = add_capsule(updates[i], &capsules[i], &cbd_data[i]); if (EFI_ERROR(rc)) { Print(L"fwupdate: Could not build update list: %r\n", rc); return rc; } } cbd_data[i].Length = 0; cbd_data[i].Union.ContinuationPointer = 0; /* * Step 3: update the state variables. */ rc = set_statuses(n_updates, updates); if (EFI_ERROR(rc)) { Print(L"fwupdate: Could not set update status: %r\n", rc); return rc; } /* * Step 4: apply the capsules. */ rc = apply_capsules(capsules, cbd_data, n_updates, &reset_type); if (EFI_ERROR(rc)) { Print(L"fwupdate: Could not apply capsules: %r\n", rc); return rc; } /* * Step 5: if #4 didn't reboot us, do it manually. */ if (debugging) { Print(L"Reset System\n"); uefi_call_wrapper(BS->Stall, 1, 10000000); } uefi_call_wrapper(RT->ResetSystem, 4, reset_type, EFI_SUCCESS, 0, NULL); return EFI_SUCCESS; }