static Menu*
add_debug_menu()
{
Menu* menu = new(std::nothrow) Menu(STANDARD_MENU, "Debug Options");
MenuItem* item;
#if DEBUG_SPINLOCK_LATENCIES
item = new(std::nothrow) MenuItem("Disable latency checks");
if (item != NULL) {
item->SetType(MENU_ITEM_MARKABLE);
item->SetData(B_SAFEMODE_DISABLE_LATENCY_CHECK);
item->SetHelpText("Disables latency check panics.");
menu->AddItem(item);
}
#endif
menu->AddItem(item
= new(nothrow) MenuItem("Enable serial debug output"));
item->SetData("serial_debug_output");
item->SetType(MENU_ITEM_MARKABLE);
item->SetHelpText("Turns on forwarding the syslog output to the serial "
"interface.");
menu->AddItem(item
= new(nothrow) MenuItem("Enable on screen debug output"));
item->SetData("debug_screen");
item->SetType(MENU_ITEM_MARKABLE);
item->SetHelpText("Displays debug output on screen while the system "
"is booting, instead of the normal boot logo.");
menu->AddItem(item = new(nothrow) MenuItem("Enable debug syslog"));
item->SetType(MENU_ITEM_MARKABLE);
item->SetMarked(gKernelArgs.keep_debug_output_buffer);
item->SetTarget(&debug_menu_toggle_debug_syslog);
item->SetHelpText("Enables a special in-memory syslog buffer for this "
"session that the boot loader will be able to access after rebooting.");
ring_buffer* syslogBuffer = (ring_buffer*)gKernelArgs.debug_output;
if (syslogBuffer != NULL && ring_buffer_readable(syslogBuffer) > 0) {
menu->AddSeparatorItem();
menu->AddItem(item
= new(nothrow) MenuItem("Display syslog from previous session"));
item->SetTarget(&debug_menu_display_syslog);
item->SetType(MENU_ITEM_NO_CHOICE);
item->SetHelpText(
"Displays the syslog from the previous Haiku session.");
menu->AddItem(item = new(nothrow) MenuItem(
"Save syslog from previous session", add_save_debug_syslog_menu()));
item->SetHelpText("Saves the syslog from the previous Haiku session to "
"disk. Currently only FAT32 volumes are supported.");
}
menu->AddSeparatorItem();
menu->AddItem(item = new(nothrow) MenuItem("Return to main menu"));
return menu;
}
static Menu*
add_safe_mode_menu()
{
Menu* safeMenu = new(nothrow) Menu(SAFE_MODE_MENU, "Safe Mode Options");
MenuItem* item;
safeMenu->AddItem(item = new(nothrow) MenuItem("Safe mode"));
item->SetData(B_SAFEMODE_SAFE_MODE);
item->SetType(MENU_ITEM_MARKABLE);
item->SetHelpText("Puts the system into safe mode. This can be enabled "
"independently from the other options.");
safeMenu->AddItem(item = new(nothrow) MenuItem("Disable user add-ons"));
item->SetData(B_SAFEMODE_DISABLE_USER_ADD_ONS);
item->SetType(MENU_ITEM_MARKABLE);
item->SetHelpText("Prevents all user installed add-ons from being loaded. "
"Only the add-ons in the system directory will be used.");
safeMenu->AddItem(item = new(nothrow) MenuItem("Disable IDE DMA"));
item->SetData(B_SAFEMODE_DISABLE_IDE_DMA);
item->SetType(MENU_ITEM_MARKABLE);
item->SetHelpText("Disables IDE DMA, increasing IDE compatibility "
"at the expense of performance.");
#if B_HAIKU_PHYSICAL_BITS > 32
// check whether we have memory beyond 4 GB
bool hasMemoryBeyond4GB = false;
for (uint32 i = 0; i < gKernelArgs.num_physical_memory_ranges; i++) {
phys_addr_range& range = gKernelArgs.physical_memory_range[i];
if (range.start >= (phys_addr_t)1 << 32) {
hasMemoryBeyond4GB = true;
break;
}
}
// ... add the menu, if so
if (hasMemoryBeyond4GB) {
safeMenu->AddItem(
item = new(nothrow) MenuItem("Ignore memory beyond 4 GiB"));
item->SetData(B_SAFEMODE_4_GB_MEMORY_LIMIT);
item->SetType(MENU_ITEM_MARKABLE);
item->SetHelpText("Ignores all memory beyond the 4 GiB address limit, "
"overriding the setting in the kernel settings file.");
}
#endif
platform_add_menus(safeMenu);
safeMenu->AddSeparatorItem();
safeMenu->AddItem(item = new(nothrow) MenuItem("Return to main menu"));
return safeMenu;
}
static Menu *
add_boot_volume_menu(Directory *bootVolume)
{
Menu *menu = new(nothrow) Menu(CHOICE_MENU, "Select Boot Volume");
MenuItem *item;
void *cookie;
int32 count = 0;
if (gRoot->Open(&cookie, O_RDONLY) == B_OK) {
Directory *volume;
while (gRoot->GetNextNode(cookie, (Node **)&volume) == B_OK) {
// only list bootable volumes
if (!is_bootable(volume))
continue;
char name[B_FILE_NAME_LENGTH];
if (volume->GetName(name, sizeof(name)) == B_OK) {
menu->AddItem(item = new(nothrow) MenuItem(name));
item->SetTarget(user_menu_boot_volume);
item->SetData(volume);
if (volume == bootVolume) {
item->SetMarked(true);
item->Select(true);
}
count++;
}
}
gRoot->Close(cookie);
}
if (count == 0) {
// no boot volume found yet
menu->AddItem(item = new(nothrow) MenuItem("<No boot volume found>"));
item->SetType(MENU_ITEM_NO_CHOICE);
item->SetEnabled(false);
}
menu->AddSeparatorItem();
menu->AddItem(item = new(nothrow) MenuItem("Rescan volumes"));
item->SetHelpText("Please insert a Antares CD-ROM or attach a USB disk - "
"depending on your system, you can then boot from them.");
item->SetType(MENU_ITEM_NO_CHOICE);
if (count == 0)
item->Select(true);
menu->AddItem(item = new(nothrow) MenuItem("Return to main menu"));
item->SetType(MENU_ITEM_NO_CHOICE);
if (gKernelArgs.boot_volume.GetBool(BOOT_VOLUME_BOOTED_FROM_IMAGE, false))
menu->SetChoiceText("CD-ROM or hard drive");
return menu;
}
void
platform_add_menus(Menu *menu)
{
MenuItem *item;
switch (menu->Type()) {
case MAIN_MENU:
item = new(std::nothrow)MenuItem("Select video mode", video_mode_menu());
if (item != NULL) {
menu->AddItem(item);
item->SetTarget(video_mode_hook);
item->SetShortcut('v');
}
break;
case SAFE_MODE_MENU:
item = new(std::nothrow) MenuItem("Use fail-safe graphics driver");
if (item != NULL) {
menu->AddItem(item);
item->SetType(MENU_ITEM_MARKABLE);
item->SetData(B_SAFEMODE_FAIL_SAFE_VIDEO_MODE);
item->SetHelpText("The system will use VESA mode "
"and won't try to use any video graphics drivers.");
}
smp_add_safemode_menus(menu);
item = new(std::nothrow) MenuItem("Disable ACPI");
if (item != NULL) {
menu->AddItem(item);
item->SetType(MENU_ITEM_MARKABLE);
item->SetData(B_SAFEMODE_DISABLE_ACPI);
item->SetHelpText("Disables Advanced Configuration and Power "
"Interface hardware support, overriding the ACPI setting "
"in the kernel settings file.");
}
break;
default:
break;
}
}
void
platform_add_menus(Menu *menu)
{
MenuItem *item;
switch (menu->Type()) {
case MAIN_MENU:
menu->AddItem(item = new(nothrow) MenuItem("Select screen resolution", video_mode_menu()));
item->SetTarget(video_mode_hook);
break;
case SAFE_MODE_MENU:
menu->AddItem(item = new(nothrow) MenuItem("Use fail-safe graphics driver"));
item->SetType(MENU_ITEM_MARKABLE);
item->SetData(B_SAFEMODE_FAIL_SAFE_VIDEO_MODE);
item->SetHelpText("The system will use VESA mode and won't try to open any video graphics driver");
#if 0
smp_add_safemode_menus(menu);
menu->AddItem(item = new(nothrow) MenuItem("Don't call the BIOS"));
item->SetType(MENU_ITEM_MARKABLE);
menu->AddItem(item = new(nothrow) MenuItem("Disable APM"));
item->SetType(MENU_ITEM_MARKABLE);
item->SetData("disable_apm");
item->SetHelpText("This overrides the APM setting in the kernel settings file");
menu->AddItem(item = new(nothrow) MenuItem("Disable ACPI"));
item->SetType(MENU_ITEM_MARKABLE);
item->SetData(B_SAFEMODE_DISABLE_ACPI);
item->SetHelpText("This overrides the ACPI setting in the kernel settings file");
#endif
break;
default:
break;
}
}
static Menu *
add_safe_mode_menu()
{
Menu *safeMenu = new(nothrow) Menu(SAFE_MODE_MENU, "Safe Mode Options");
MenuItem *item;
safeMenu->AddItem(item = new(nothrow) MenuItem("Safe mode"));
item->SetData(B_SAFEMODE_SAFE_MODE);
item->SetType(MENU_ITEM_MARKABLE);
item->SetHelpText("Puts the system into safe mode. This can be enabled "
"independently from the other options.");
safeMenu->AddItem(item = new(nothrow) MenuItem("Disable user add-ons"));
item->SetData(B_SAFEMODE_DISABLE_USER_ADD_ONS);
item->SetType(MENU_ITEM_MARKABLE);
item->SetHelpText("Prevents all user installed add-ons from being loaded. "
"Only the add-ons in the system directory will be used.");
safeMenu->AddItem(item = new(nothrow) MenuItem("Disable IDE DMA"));
item->SetData(B_SAFEMODE_DISABLE_IDE_DMA);
item->SetType(MENU_ITEM_MARKABLE);
item->SetHelpText("Disables IDE DMA, increasing IDE compatibilty "
"at the expense of performance.");
platform_add_menus(safeMenu);
#if DEBUG_SPINLOCK_LATENCIES
item = new(std::nothrow) MenuItem("Disable latency checks");
if (item != NULL) {
item->SetType(MENU_ITEM_MARKABLE);
item->SetData(B_SAFEMODE_DISABLE_LATENCY_CHECK);
item->SetHelpText("Disables latency check panics.");
safeMenu->AddItem(item);
}
#endif
safeMenu->AddItem(item
= new(nothrow) MenuItem("Enable serial debug output"));
item->SetData("serial_debug_output");
item->SetType(MENU_ITEM_MARKABLE);
item->SetHelpText("Turns on forwarding the syslog output to the serial "
"interface.");
safeMenu->AddItem(item
= new(nothrow) MenuItem("Enable on screen debug output"));
item->SetData("debug_screen");
item->SetType(MENU_ITEM_MARKABLE);
item->SetHelpText("Displays debug output on screen while the system "
"is booting, instead of the normal boot logo.");
safeMenu->AddSeparatorItem();
safeMenu->AddItem(item = new(nothrow) MenuItem("Return to main menu"));
return safeMenu;
}
static bool
user_menu_boot_volume(Menu *menu, MenuItem *item)
{
Menu *super = menu->Supermenu();
if (super == NULL) {
// huh?
return true;
}
MenuItem *bootItem = super->ItemAt(super->CountItems() - 1);
bootItem->SetEnabled(true);
bootItem->Select(true);
bootItem->SetData(item->Data());
gKernelArgs.boot_volume.SetBool(BOOT_VOLUME_USER_SELECTED, true);
return true;
}
void
platform_add_menus(Menu* menu)
{
MenuItem* item;
switch (menu->Type()) {
case MAIN_MENU:
case SAFE_MODE_MENU:
menu->AddItem(item = new(nothrow) MenuItem("A menu item"));
item->SetType(MENU_ITEM_MARKABLE);
item->SetData(0);
item->SetHelpText("A helpful text.");
menu->AddItem(item = new(nothrow) MenuItem("Another menu item"));
item->SetHelpText("Some more helpful text.");
item->SetType(MENU_ITEM_MARKABLE);
break;
default:
break;
}
}
static Menu*
add_save_debug_syslog_menu()
{
Menu* menu = new(nothrow) Menu(STANDARD_MENU, "Save syslog to volume ...");
MenuItem* item;
const char* const kHelpText = "Currently only FAT32 volumes are supported. "
"Newly plugged in removable devices are only recognized after "
"rebooting.";
int32 itemsAdded = 0;
void* cookie;
if (gRoot->Open(&cookie, O_RDONLY) == B_OK) {
Node* node;
while (gRoot->GetNextNode(cookie, &node) == B_OK) {
Directory* volume = static_cast<Directory*>(node);
Partition* partition;
if (gRoot->GetPartitionFor(volume, &partition) != B_OK)
continue;
// we support only FAT32 volumes ATM
if (partition->content_type == NULL
|| strcmp(partition->content_type, kPartitionTypeFAT32) != 0) {
continue;
}
char name[B_FILE_NAME_LENGTH];
if (volume->GetName(name, sizeof(name)) != B_OK)
strcpy(name, "unnamed");
// append offset, size, and type to the name
size_t len = strlen(name);
char offsetBuffer[32];
char sizeBuffer[32];
snprintf(name + len, sizeof(name) - len,
" (%s, offset %s, size %s)", partition->content_type,
size_to_string(partition->offset, offsetBuffer,
sizeof(offsetBuffer)),
size_to_string(partition->size, sizeBuffer,
sizeof(sizeBuffer)));
item = new(nothrow) MenuItem(name);
item->SetData(volume);
item->SetTarget(&debug_menu_save_syslog);
item->SetType(MENU_ITEM_NO_CHOICE);
item->SetHelpText(kHelpText);
menu->AddItem(item);
itemsAdded++;
}
gRoot->Close(cookie);
}
if (itemsAdded == 0) {
menu->AddItem(item
= new(nothrow) MenuItem("No supported volumes found"));
item->SetType(MENU_ITEM_NO_CHOICE);
item->SetHelpText(kHelpText);
item->SetEnabled(false);
}
menu->AddSeparatorItem();
menu->AddItem(item = new(nothrow) MenuItem("Return to debug menu"));
item->SetHelpText(kHelpText);
return menu;
}
static Menu*
add_debug_menu()
{
Menu* menu = new(std::nothrow) Menu(STANDARD_MENU, "Debug Options");
MenuItem* item;
#if DEBUG_SPINLOCK_LATENCIES
item = new(std::nothrow) MenuItem("Disable latency checks");
if (item != NULL) {
item->SetType(MENU_ITEM_MARKABLE);
item->SetData(B_SAFEMODE_DISABLE_LATENCY_CHECK);
item->SetHelpText("Disables latency check panics.");
menu->AddItem(item);
}
#endif
menu->AddItem(item
= new(nothrow) MenuItem("Enable serial debug output"));
item->SetData("serial_debug_output");
item->SetType(MENU_ITEM_MARKABLE);
item->SetHelpText("Turns on forwarding the syslog output to the serial "
"interface (default: 115200, 8N1).");
menu->AddItem(item
= new(nothrow) MenuItem("Enable on screen debug output"));
item->SetData("debug_screen");
item->SetType(MENU_ITEM_MARKABLE);
item->SetHelpText("Displays debug output on screen while the system "
"is booting, instead of the normal boot logo.");
menu->AddItem(item
= new(nothrow) MenuItem("Disable on screen paging"));
item->SetData("disable_onscreen_paging");
item->SetType(MENU_ITEM_MARKABLE);
item->SetHelpText("Disables paging when on screen debug output is "
"enabled.");
menu->AddItem(item = new(nothrow) MenuItem("Enable debug syslog"));
item->SetType(MENU_ITEM_MARKABLE);
item->SetMarked(gKernelArgs.keep_debug_output_buffer);
item->SetTarget(&debug_menu_toggle_debug_syslog);
item->SetHelpText("Enables a special in-memory syslog buffer for this "
"session that the boot loader will be able to access after rebooting.");
ring_buffer* syslogBuffer
= (ring_buffer*)gKernelArgs.debug_output.Pointer();
bool hasPreviousSyslog
= syslogBuffer != NULL && ring_buffer_readable(syslogBuffer) > 0;
if (hasPreviousSyslog) {
menu->AddItem(item = new(nothrow) MenuItem(
"Save syslog from previous session during boot"));
item->SetType(MENU_ITEM_MARKABLE);
item->SetMarked(gKernelArgs.previous_debug_size);
item->SetTarget(&debug_menu_toggle_previous_debug_syslog);
item->SetHelpText("Saves the syslog from the previous Haiku session to "
"/var/log/previous_syslog when booting.");
}
bool currentLogItemVisible = platform_debug_get_log_buffer(NULL) != NULL;
if (currentLogItemVisible) {
menu->AddSeparatorItem();
menu->AddItem(item
= new(nothrow) MenuItem("Display current boot loader log"));
item->SetTarget(&debug_menu_display_current_log);
item->SetType(MENU_ITEM_NO_CHOICE);
item->SetHelpText(
"Displays the debug info the boot loader has logged.");
}
if (hasPreviousSyslog) {
if (!currentLogItemVisible)
menu->AddSeparatorItem();
menu->AddItem(item
= new(nothrow) MenuItem("Display syslog from previous session"));
item->SetTarget(&debug_menu_display_previous_syslog);
item->SetType(MENU_ITEM_NO_CHOICE);
item->SetHelpText(
"Displays the syslog from the previous Haiku session.");
menu->AddItem(item = new(nothrow) MenuItem(
"Save syslog from previous session", add_save_debug_syslog_menu()));
item->SetHelpText("Saves the syslog from the previous Haiku session to "
"disk. Currently only FAT32 volumes are supported.");
}
menu->AddSeparatorItem();
menu->AddItem(item = new(nothrow) MenuItem(
"Add advanced debug option"));
item->SetType(MENU_ITEM_NO_CHOICE);
item->SetTarget(&debug_menu_add_advanced_option);
item->SetHelpText(
"Allows advanced debugging options to be entered directly.");
menu->AddSeparatorItem();
menu->AddItem(item = new(nothrow) MenuItem("Return to main menu"));
return menu;
}
static Menu*
add_safe_mode_menu()
{
Menu* safeMenu = new(nothrow) Menu(SAFE_MODE_MENU, "Safe Mode Options");
MenuItem* item;
safeMenu->AddItem(item = new(nothrow) MenuItem("Safe mode"));
item->SetData(B_SAFEMODE_SAFE_MODE);
item->SetType(MENU_ITEM_MARKABLE);
item->SetHelpText("Puts the system into safe mode. This can be enabled "
"independently from the other options.");
safeMenu->AddItem(item = new(nothrow) MenuItem("Disable user add-ons"));
item->SetData(B_SAFEMODE_DISABLE_USER_ADD_ONS);
item->SetType(MENU_ITEM_MARKABLE);
item->SetHelpText("Prevents all user installed add-ons from being loaded. "
"Only the add-ons in the system directory will be used.");
safeMenu->AddItem(item = new(nothrow) MenuItem("Disable IDE DMA"));
item->SetData(B_SAFEMODE_DISABLE_IDE_DMA);
item->SetType(MENU_ITEM_MARKABLE);
item->SetHelpText("Disables IDE DMA, increasing IDE compatibility "
"at the expense of performance.");
#if B_HAIKU_PHYSICAL_BITS > 32
// check whether we have memory beyond 4 GB
bool hasMemoryBeyond4GB = false;
for (uint32 i = 0; i < gKernelArgs.num_physical_memory_ranges; i++) {
addr_range& range = gKernelArgs.physical_memory_range[i];
if (range.start >= (uint64)1 << 32) {
hasMemoryBeyond4GB = true;
break;
}
}
bool needs64BitPaging = true;
// TODO: Determine whether 64 bit paging (i.e. PAE for x86) is needed
// for other reasons (NX support).
// ... add the menu item, if so
if (hasMemoryBeyond4GB || needs64BitPaging) {
safeMenu->AddItem(
item = new(nothrow) MenuItem("Ignore memory beyond 4 GiB"));
item->SetData(B_SAFEMODE_4_GB_MEMORY_LIMIT);
item->SetType(MENU_ITEM_MARKABLE);
item->SetHelpText("Ignores all memory beyond the 4 GiB address limit, "
"overriding the setting in the kernel settings file.");
}
#endif
platform_add_menus(safeMenu);
safeMenu->AddSeparatorItem();
sBlacklistRootMenu = new(std::nothrow) BlacklistRootMenu;
safeMenu->AddItem(item = new(std::nothrow) MenuItem("Blacklist entries",
sBlacklistRootMenu));
item->SetHelpText("Allows to select system files that shall be ignored. "
"Useful e.g. to disable drivers temporarily.");
safeMenu->AddSeparatorItem();
safeMenu->AddItem(item = new(nothrow) MenuItem("Return to main menu"));
return safeMenu;
}