1 /* 2 * Copyright 2003-2013, Axel Dörfler, axeld@pinc-software.de. 3 * Copyright 2011, Rene Gollent, rene@gollent.com. 4 * Copyright 2013-2014, Ingo Weinhold, ingo_weinhold@gmx.de. 5 * Distributed under the terms of the MIT License. 6 */ 7 8 9 #include "menu.h" 10 11 #include <errno.h> 12 #include <strings.h> 13 14 #include <algorithm> 15 16 #include <OS.h> 17 18 #include <AutoDeleter.h> 19 #include <boot/menu.h> 20 #include <boot/PathBlacklist.h> 21 #include <boot/stage2.h> 22 #include <boot/vfs.h> 23 #include <boot/platform.h> 24 #include <boot/platform/generic/text_console.h> 25 #include <boot/stdio.h> 26 #include <safemode.h> 27 #include <util/ring_buffer.h> 28 #include <util/SinglyLinkedList.h> 29 30 #include "kernel_debug_config.h" 31 32 #include "load_driver_settings.h" 33 #include "loader.h" 34 #include "package_support.h" 35 #include "pager.h" 36 #include "RootFileSystem.h" 37 38 39 //#define TRACE_MENU 40 #ifdef TRACE_MENU 41 # define TRACE(x) dprintf x 42 #else 43 # define TRACE(x) ; 44 #endif 45 46 47 // only set while in user_menu() 48 static Menu* sMainMenu = NULL; 49 static Menu* sBlacklistRootMenu = NULL; 50 static BootVolume* sBootVolume = NULL; 51 static PathBlacklist* sPathBlacklist; 52 53 54 MenuItem::MenuItem(const char *label, Menu *subMenu) 55 : 56 fLabel(strdup(label)), 57 fTarget(NULL), 58 fIsMarked(false), 59 fIsSelected(false), 60 fIsEnabled(true), 61 fType(MENU_ITEM_STANDARD), 62 fMenu(NULL), 63 fSubMenu(NULL), 64 fData(NULL), 65 fHelpText(NULL), 66 fShortcut(0) 67 { 68 SetSubmenu(subMenu); 69 } 70 71 72 MenuItem::~MenuItem() 73 { 74 delete fSubMenu; 75 free(const_cast<char *>(fLabel)); 76 } 77 78 79 void 80 MenuItem::SetTarget(menu_item_hook target) 81 { 82 fTarget = target; 83 } 84 85 86 /** Marks or unmarks a menu item. A marked menu item usually gets a visual 87 * clue like a checkmark that distinguishes it from others. 88 * For menus of type CHOICE_MENU, there can only be one marked item - the 89 * chosen one. 90 */ 91 92 void 93 MenuItem::SetMarked(bool marked) 94 { 95 if (marked && fMenu != NULL && fMenu->Type() == CHOICE_MENU) { 96 // always set choice text of parent if we were marked 97 fMenu->SetChoiceText(Label()); 98 } 99 100 if (fIsMarked == marked) 101 return; 102 103 if (marked && fMenu != NULL && fMenu->Type() == CHOICE_MENU) { 104 // unmark previous item 105 MenuItem *markedItem = fMenu->FindMarked(); 106 if (markedItem != NULL) 107 markedItem->SetMarked(false); 108 } 109 110 fIsMarked = marked; 111 112 if (fMenu != NULL) 113 fMenu->Draw(this); 114 } 115 116 117 void 118 MenuItem::Select(bool selected) 119 { 120 if (fIsSelected == selected) 121 return; 122 123 if (selected && fMenu != NULL) { 124 // unselect previous item 125 MenuItem *selectedItem = fMenu->FindSelected(); 126 if (selectedItem != NULL) 127 selectedItem->Select(false); 128 } 129 130 fIsSelected = selected; 131 132 if (fMenu != NULL) 133 fMenu->Draw(this); 134 } 135 136 137 void 138 MenuItem::SetType(menu_item_type type) 139 { 140 fType = type; 141 } 142 143 144 void 145 MenuItem::SetEnabled(bool enabled) 146 { 147 if (fIsEnabled == enabled) 148 return; 149 150 fIsEnabled = enabled; 151 152 if (fMenu != NULL) 153 fMenu->Draw(this); 154 } 155 156 157 void 158 MenuItem::SetData(const void *data) 159 { 160 fData = data; 161 } 162 163 164 /*! This sets a help text that is shown when the item is 165 selected. 166 Note, unlike the label, the string is not copied, it's 167 just referenced and has to stay valid as long as the 168 item's menu is being used. 169 */ 170 void 171 MenuItem::SetHelpText(const char* text) 172 { 173 fHelpText = text; 174 } 175 176 177 void 178 MenuItem::SetShortcut(char key) 179 { 180 fShortcut = key; 181 } 182 183 184 void 185 MenuItem::SetLabel(const char* label) 186 { 187 if (char* newLabel = strdup(label)) { 188 free(const_cast<char*>(fLabel)); 189 fLabel = newLabel; 190 } 191 } 192 193 194 void 195 MenuItem::SetSubmenu(Menu* subMenu) 196 { 197 fSubMenu = subMenu; 198 199 if (fSubMenu != NULL) 200 fSubMenu->fSuperItem = this; 201 } 202 203 204 void 205 MenuItem::SetMenu(Menu* menu) 206 { 207 fMenu = menu; 208 } 209 210 211 // #pragma mark - 212 213 214 Menu::Menu(menu_type type, const char* title) 215 : 216 fTitle(title), 217 fChoiceText(NULL), 218 fCount(0), 219 fIsHidden(true), 220 fType(type), 221 fSuperItem(NULL), 222 fShortcuts(NULL) 223 { 224 } 225 226 227 Menu::~Menu() 228 { 229 // take all remaining items with us 230 231 MenuItem *item; 232 while ((item = fItems.Head()) != NULL) { 233 fItems.Remove(item); 234 delete item; 235 } 236 } 237 238 239 void 240 Menu::Entered() 241 { 242 } 243 244 245 void 246 Menu::Exited() 247 { 248 } 249 250 251 MenuItem* 252 Menu::ItemAt(int32 index) 253 { 254 if (index < 0 || index >= fCount) 255 return NULL; 256 257 MenuItemIterator iterator = ItemIterator(); 258 MenuItem *item; 259 260 while ((item = iterator.Next()) != NULL) { 261 if (index-- == 0) 262 return item; 263 } 264 265 return NULL; 266 } 267 268 269 int32 270 Menu::IndexOf(MenuItem* searchedItem) 271 { 272 int32 index = 0; 273 274 MenuItemIterator iterator = ItemIterator(); 275 while (MenuItem* item = iterator.Next()) { 276 if (item == searchedItem) 277 return index; 278 279 index++; 280 } 281 282 return -1; 283 } 284 285 286 int32 287 Menu::CountItems() const 288 { 289 return fCount; 290 } 291 292 293 MenuItem* 294 Menu::FindItem(const char* label) 295 { 296 MenuItemIterator iterator = ItemIterator(); 297 while (MenuItem* item = iterator.Next()) { 298 if (item->Label() != NULL && !strcmp(item->Label(), label)) 299 return item; 300 } 301 302 return NULL; 303 } 304 305 306 MenuItem* 307 Menu::FindMarked() 308 { 309 MenuItemIterator iterator = ItemIterator(); 310 while (MenuItem* item = iterator.Next()) { 311 if (item->IsMarked()) 312 return item; 313 } 314 315 return NULL; 316 } 317 318 319 MenuItem* 320 Menu::FindSelected(int32* _index) 321 { 322 int32 index = 0; 323 324 MenuItemIterator iterator = ItemIterator(); 325 while (MenuItem* item = iterator.Next()) { 326 if (item->IsSelected()) { 327 if (_index != NULL) 328 *_index = index; 329 return item; 330 } 331 332 index++; 333 } 334 335 return NULL; 336 } 337 338 339 void 340 Menu::AddItem(MenuItem* item) 341 { 342 item->fMenu = this; 343 fItems.Add(item); 344 fCount++; 345 } 346 347 348 status_t 349 Menu::AddSeparatorItem() 350 { 351 MenuItem* item = new(std::nothrow) MenuItem(); 352 if (item == NULL) 353 return B_NO_MEMORY; 354 355 item->SetType(MENU_ITEM_SEPARATOR); 356 357 AddItem(item); 358 return B_OK; 359 } 360 361 362 MenuItem* 363 Menu::RemoveItemAt(int32 index) 364 { 365 if (index < 0 || index >= fCount) 366 return NULL; 367 368 MenuItemIterator iterator = ItemIterator(); 369 while (MenuItem* item = iterator.Next()) { 370 if (index-- == 0) { 371 RemoveItem(item); 372 return item; 373 } 374 } 375 376 return NULL; 377 } 378 379 380 void 381 Menu::RemoveItem(MenuItem* item) 382 { 383 item->fMenu = NULL; 384 fItems.Remove(item); 385 fCount--; 386 } 387 388 389 void 390 Menu::AddShortcut(char key, shortcut_hook function) 391 { 392 Menu::shortcut* shortcut = new(std::nothrow) Menu::shortcut; 393 if (shortcut == NULL) 394 return; 395 396 shortcut->key = key; 397 shortcut->function = function; 398 399 shortcut->next = fShortcuts; 400 fShortcuts = shortcut; 401 } 402 403 404 shortcut_hook 405 Menu::FindShortcut(char key) const 406 { 407 if (key == 0) 408 return NULL; 409 410 const Menu::shortcut* shortcut = fShortcuts; 411 while (shortcut != NULL) { 412 if (shortcut->key == key) 413 return shortcut->function; 414 415 shortcut = shortcut->next; 416 } 417 418 Menu *superMenu = Supermenu(); 419 420 if (superMenu != NULL) 421 return superMenu->FindShortcut(key); 422 423 return NULL; 424 } 425 426 427 MenuItem* 428 Menu::FindItemByShortcut(char key) 429 { 430 if (key == 0) 431 return NULL; 432 433 MenuItemList::Iterator iterator = ItemIterator(); 434 while (MenuItem* item = iterator.Next()) { 435 if (item->Shortcut() == key) 436 return item; 437 } 438 439 Menu *superMenu = Supermenu(); 440 441 if (superMenu != NULL) 442 return superMenu->FindItemByShortcut(key); 443 444 return NULL; 445 } 446 447 448 void 449 Menu::SortItems(bool (*less)(const MenuItem*, const MenuItem*)) 450 { 451 fItems.Sort(less); 452 } 453 454 455 void 456 Menu::Run() 457 { 458 platform_run_menu(this); 459 } 460 461 462 void 463 Menu::Draw(MenuItem* item) 464 { 465 if (!IsHidden()) 466 platform_update_menu_item(this, item); 467 } 468 469 470 // #pragma mark - 471 472 473 static const char* 474 size_to_string(off_t size, char* buffer, size_t bufferSize) 475 { 476 static const char* const kPrefixes[] = { "K", "M", "G", "T", "P", NULL }; 477 int32 nextIndex = 0; 478 int32 remainder = 0; 479 while (size >= 1024 && kPrefixes[nextIndex] != NULL) { 480 remainder = size % 1024; 481 size /= 1024; 482 nextIndex++; 483 484 if (size < 1024) { 485 // Compute the decimal remainder and make sure we have at most 486 // 3 decimal places (or 4 for 1000 <= size <= 1023). 487 int32 factor; 488 if (size >= 100) 489 factor = 100; 490 else if (size >= 10) 491 factor = 10; 492 else 493 factor = 1; 494 495 remainder = (remainder * 1000 + 5 * factor) / 1024; 496 497 if (remainder >= 1000) { 498 size++; 499 remainder = 0; 500 } else 501 remainder /= 10 * factor; 502 } else 503 size += (remainder + 512) / 1024; 504 } 505 506 if (remainder == 0) { 507 snprintf(buffer, bufferSize, "%" B_PRIdOFF, size); 508 } else { 509 snprintf(buffer, bufferSize, "%" B_PRIdOFF ".%" B_PRId32, size, 510 remainder); 511 } 512 513 size_t length = strlen(buffer); 514 snprintf(buffer + length, bufferSize - length, " %sB", 515 nextIndex == 0 ? "" : kPrefixes[nextIndex - 1]); 516 517 return buffer; 518 } 519 520 521 // #pragma mark - blacklist menu 522 523 524 class BlacklistMenuItem : public MenuItem { 525 public: 526 BlacklistMenuItem(char* label, Node* node, Menu* subMenu) 527 : 528 MenuItem(label, subMenu), 529 fNode(node), 530 fSubMenu(subMenu) 531 { 532 fNode->Acquire(); 533 SetType(MENU_ITEM_MARKABLE); 534 } 535 536 ~BlacklistMenuItem() 537 { 538 fNode->Release(); 539 540 // make sure the submenu is destroyed 541 SetSubmenu(fSubMenu); 542 } 543 544 bool IsDirectoryItem() const 545 { 546 return fNode->Type() == S_IFDIR; 547 } 548 549 bool GetPath(BlacklistedPath& _path) const 550 { 551 Menu* menu = Supermenu(); 552 if (menu != NULL && menu != sBlacklistRootMenu 553 && menu->Superitem() != NULL) { 554 return static_cast<BlacklistMenuItem*>(menu->Superitem()) 555 ->GetPath(_path) 556 && _path.Append(Label()); 557 } 558 559 return _path.SetTo(Label()); 560 } 561 562 void UpdateBlacklisted() 563 { 564 BlacklistedPath path; 565 if (GetPath(path)) 566 _SetMarked(sPathBlacklist->Contains(path.Path()), false); 567 } 568 569 virtual void SetMarked(bool marked) 570 { 571 _SetMarked(marked, true); 572 } 573 574 static bool Less(const MenuItem* a, const MenuItem* b) 575 { 576 const BlacklistMenuItem* item1 577 = static_cast<const BlacklistMenuItem*>(a); 578 const BlacklistMenuItem* item2 579 = static_cast<const BlacklistMenuItem*>(b); 580 581 // directories come first 582 if (item1->IsDirectoryItem() != item2->IsDirectoryItem()) 583 return item1->IsDirectoryItem(); 584 585 // compare the labels 586 return strcasecmp(item1->Label(), item2->Label()) < 0; 587 } 588 589 private: 590 void _SetMarked(bool marked, bool updateBlacklist) 591 { 592 if (marked == IsMarked()) 593 return; 594 595 // For directories toggle the availability of the submenu. 596 if (IsDirectoryItem()) 597 SetSubmenu(marked ? NULL : fSubMenu); 598 599 if (updateBlacklist) { 600 BlacklistedPath path; 601 if (GetPath(path)) { 602 if (marked) 603 sPathBlacklist->Add(path.Path()); 604 else 605 sPathBlacklist->Remove(path.Path()); 606 } 607 } 608 609 MenuItem::SetMarked(marked); 610 } 611 612 private: 613 Node* fNode; 614 Menu* fSubMenu; 615 }; 616 617 618 class BlacklistMenu : public Menu { 619 public: 620 BlacklistMenu() 621 : 622 Menu(STANDARD_MENU, kDefaultMenuTitle), 623 fDirectory(NULL) 624 { 625 } 626 627 ~BlacklistMenu() 628 { 629 SetDirectory(NULL); 630 } 631 632 virtual void Entered() 633 { 634 _DeleteItems(); 635 636 if (fDirectory != NULL) { 637 void* cookie; 638 if (fDirectory->Open(&cookie, O_RDONLY) == B_OK) { 639 Node* node; 640 while (fDirectory->GetNextNode(cookie, &node) == B_OK) { 641 BlacklistMenuItem* item = _CreateItem(node); 642 node->Release(); 643 if (item == NULL) 644 break; 645 646 AddItem(item); 647 648 item->UpdateBlacklisted(); 649 } 650 fDirectory->Close(cookie); 651 } 652 653 SortItems(&BlacklistMenuItem::Less); 654 } 655 656 if (CountItems() > 0) 657 AddSeparatorItem(); 658 AddItem(new(nothrow) MenuItem("Return to parent directory")); 659 } 660 661 virtual void Exited() 662 { 663 _DeleteItems(); 664 } 665 666 protected: 667 void SetDirectory(Directory* directory) 668 { 669 if (fDirectory != NULL) 670 fDirectory->Release(); 671 672 fDirectory = directory; 673 674 if (fDirectory != NULL) 675 fDirectory->Acquire(); 676 } 677 678 private: 679 static BlacklistMenuItem* _CreateItem(Node* node) 680 { 681 // Get the node name and duplicate it, so we can use it as a label. 682 char name[B_FILE_NAME_LENGTH]; 683 if (node->GetName(name, sizeof(name)) != B_OK) 684 return NULL; 685 686 // append '/' to directory labels 687 bool isDirectory = node->Type() == S_IFDIR; 688 if (isDirectory) 689 strlcat(name, "/", sizeof(name)); 690 691 // If this is a directory, create the submenu. 692 BlacklistMenu* subMenu = NULL; 693 if (isDirectory) { 694 subMenu = new(std::nothrow) BlacklistMenu; 695 if (subMenu != NULL) 696 subMenu->SetDirectory(static_cast<Directory*>(node)); 697 698 } 699 ObjectDeleter<BlacklistMenu> subMenuDeleter(subMenu); 700 701 // create the menu item 702 BlacklistMenuItem* item = new(std::nothrow) BlacklistMenuItem(name, 703 node, subMenu); 704 if (item == NULL) 705 return NULL; 706 707 subMenuDeleter.Detach(); 708 return item; 709 } 710 711 void _DeleteItems() 712 { 713 int32 count = CountItems(); 714 for (int32 i = 0; i < count; i++) 715 delete RemoveItemAt(0); 716 } 717 718 private: 719 Directory* fDirectory; 720 721 protected: 722 static const char* const kDefaultMenuTitle; 723 }; 724 725 726 const char* const BlacklistMenu::kDefaultMenuTitle 727 = "Mark the entries to blacklist"; 728 729 730 class BlacklistRootMenu : public BlacklistMenu { 731 public: 732 BlacklistRootMenu() 733 : 734 BlacklistMenu() 735 { 736 } 737 738 virtual void Entered() 739 { 740 // Get the system directory, but only if this is a packaged Haiku. 741 // Otherwise blacklisting isn't supported. 742 if (sBootVolume != NULL && sBootVolume->IsValid() 743 && sBootVolume->IsPackaged()) { 744 SetDirectory(sBootVolume->SystemDirectory()); 745 SetTitle(kDefaultMenuTitle); 746 } else { 747 SetDirectory(NULL); 748 SetTitle(sBootVolume != NULL && sBootVolume->IsValid() 749 ? "The selected boot volume doesn't support blacklisting!" 750 : "No boot volume selected!"); 751 } 752 753 BlacklistMenu::Entered(); 754 755 // rename last item 756 if (MenuItem* item = ItemAt(CountItems() - 1)) 757 item->SetLabel("Return to safe mode menu"); 758 } 759 760 virtual void Exited() 761 { 762 BlacklistMenu::Exited(); 763 SetDirectory(NULL); 764 } 765 }; 766 767 768 // #pragma mark - boot volume menu 769 770 771 class BootVolumeMenuItem : public MenuItem { 772 public: 773 BootVolumeMenuItem(const char* volumeName) 774 : 775 MenuItem(volumeName), 776 fStateChoiceText(NULL) 777 { 778 } 779 780 ~BootVolumeMenuItem() 781 { 782 UpdateStateName(NULL); 783 } 784 785 void UpdateStateName(PackageVolumeState* volumeState) 786 { 787 free(fStateChoiceText); 788 fStateChoiceText = NULL; 789 790 if (volumeState != NULL && volumeState->Name() != NULL) { 791 char nameBuffer[128]; 792 snprintf(nameBuffer, sizeof(nameBuffer), "%s (%s)", Label(), 793 volumeState->DisplayName()); 794 fStateChoiceText = strdup(nameBuffer); 795 } 796 797 Supermenu()->SetChoiceText( 798 fStateChoiceText != NULL ? fStateChoiceText : Label()); 799 } 800 801 private: 802 char* fStateChoiceText; 803 }; 804 805 806 class PackageVolumeStateMenuItem : public MenuItem { 807 public: 808 PackageVolumeStateMenuItem(const char* label, PackageVolumeInfo* volumeInfo, 809 PackageVolumeState* volumeState) 810 : 811 MenuItem(label), 812 fVolumeInfo(volumeInfo), 813 fVolumeState(volumeState) 814 { 815 fVolumeInfo->AcquireReference(); 816 } 817 818 ~PackageVolumeStateMenuItem() 819 { 820 fVolumeInfo->ReleaseReference(); 821 } 822 823 PackageVolumeInfo* VolumeInfo() const 824 { 825 return fVolumeInfo; 826 } 827 828 PackageVolumeState* VolumeState() const 829 { 830 return fVolumeState; 831 } 832 833 private: 834 PackageVolumeInfo* fVolumeInfo; 835 PackageVolumeState* fVolumeState; 836 }; 837 838 839 // #pragma mark - 840 841 842 class StringBuffer { 843 public: 844 StringBuffer() 845 : 846 fBuffer(NULL), 847 fLength(0), 848 fCapacity(0) 849 { 850 } 851 852 ~StringBuffer() 853 { 854 free(fBuffer); 855 } 856 857 const char* String() const 858 { 859 return fBuffer != NULL ? fBuffer : ""; 860 } 861 862 size_t Length() const 863 { 864 return fLength; 865 } 866 867 bool Append(const char* toAppend) 868 { 869 return Append(toAppend, strlen(toAppend)); 870 } 871 872 bool Append(const char* toAppend, size_t length) 873 { 874 size_t oldLength = fLength; 875 if (!_Resize(fLength + length)) 876 return false; 877 878 memcpy(fBuffer + oldLength, toAppend, length); 879 return true; 880 } 881 882 private: 883 bool _Resize(size_t newLength) 884 { 885 if (newLength >= fCapacity) { 886 size_t newCapacity = std::max(fCapacity, size_t(32)); 887 while (newLength >= newCapacity) 888 newCapacity *= 2; 889 890 char* buffer = (char*)realloc(fBuffer, newCapacity); 891 if (buffer == NULL) 892 return false; 893 894 fBuffer = buffer; 895 fCapacity = newCapacity; 896 } 897 898 fBuffer[newLength] = '\0'; 899 fLength = newLength; 900 return true; 901 } 902 903 private: 904 char* fBuffer; 905 size_t fLength; 906 size_t fCapacity; 907 }; 908 909 910 // #pragma mark - 911 912 913 static StringBuffer sSafeModeOptionsBuffer; 914 915 916 static MenuItem* 917 get_continue_booting_menu_item() 918 { 919 // It's the last item in the main menu. 920 if (sMainMenu == NULL || sMainMenu->CountItems() == 0) 921 return NULL; 922 return sMainMenu->ItemAt(sMainMenu->CountItems() - 1); 923 } 924 925 926 static bool 927 user_menu_boot_volume(Menu* menu, MenuItem* item) 928 { 929 MenuItem* bootItem = get_continue_booting_menu_item(); 930 if (bootItem == NULL) { 931 // huh? 932 return true; 933 } 934 935 if (sBootVolume->IsValid() && sBootVolume->RootDirectory() == item->Data()) 936 return true; 937 938 sPathBlacklist->MakeEmpty(); 939 940 bool valid = sBootVolume->SetTo((Directory*)item->Data()) == B_OK; 941 942 bootItem->SetEnabled(valid); 943 if (valid) 944 bootItem->Select(true); 945 946 gBootVolume.SetBool(BOOT_VOLUME_USER_SELECTED, true); 947 return true; 948 } 949 950 951 static bool 952 user_menu_boot_volume_state(Menu* menu, MenuItem* _item) 953 { 954 MenuItem* bootItem = get_continue_booting_menu_item(); 955 if (bootItem == NULL) { 956 // huh? 957 return true; 958 } 959 960 PackageVolumeStateMenuItem* item = static_cast<PackageVolumeStateMenuItem*>( 961 _item); 962 if (sBootVolume->IsValid() && sBootVolume->GetPackageVolumeState() != NULL 963 && sBootVolume->GetPackageVolumeState() == item->VolumeState()) { 964 return true; 965 } 966 967 BootVolumeMenuItem* volumeItem = static_cast<BootVolumeMenuItem*>( 968 item->Supermenu()->Superitem()); 969 volumeItem->SetMarked(true); 970 volumeItem->Select(true); 971 volumeItem->UpdateStateName(item->VolumeState()); 972 973 sPathBlacklist->MakeEmpty(); 974 975 bool valid = sBootVolume->SetTo((Directory*)item->Data(), 976 item->VolumeInfo(), item->VolumeState()) == B_OK; 977 978 bootItem->SetEnabled(valid); 979 if (valid) 980 bootItem->Select(true); 981 982 gBootVolume.SetBool(BOOT_VOLUME_USER_SELECTED, true); 983 return true; 984 } 985 986 987 static bool 988 debug_menu_display_current_log(Menu* menu, MenuItem* item) 989 { 990 // get the buffer 991 size_t bufferSize; 992 const char* buffer = platform_debug_get_log_buffer(&bufferSize); 993 if (buffer == NULL || bufferSize == 0) 994 return true; 995 996 struct TextSource : PagerTextSource { 997 TextSource(const char* buffer, size_t size) 998 : 999 fBuffer(buffer), 1000 fSize(strnlen(buffer, size)) 1001 { 1002 } 1003 1004 virtual size_t BytesAvailable() const 1005 { 1006 return fSize; 1007 } 1008 1009 virtual size_t Read(size_t offset, void* buffer, size_t size) const 1010 { 1011 if (offset >= fSize) 1012 return 0; 1013 1014 if (size > fSize - offset) 1015 size = fSize - offset; 1016 1017 memcpy(buffer, fBuffer + offset, size); 1018 return size; 1019 } 1020 1021 private: 1022 const char* fBuffer; 1023 size_t fSize; 1024 }; 1025 1026 pager(TextSource(buffer, bufferSize)); 1027 1028 return true; 1029 } 1030 1031 1032 static bool 1033 debug_menu_display_previous_syslog(Menu* menu, MenuItem* item) 1034 { 1035 ring_buffer* buffer = (ring_buffer*)gKernelArgs.debug_output.Pointer(); 1036 if (buffer == NULL) 1037 return true; 1038 1039 struct TextSource : PagerTextSource { 1040 TextSource(ring_buffer* buffer) 1041 : 1042 fBuffer(buffer) 1043 { 1044 } 1045 1046 virtual size_t BytesAvailable() const 1047 { 1048 return ring_buffer_readable(fBuffer); 1049 } 1050 1051 virtual size_t Read(size_t offset, void* buffer, size_t size) const 1052 { 1053 return ring_buffer_peek(fBuffer, offset, buffer, size); 1054 } 1055 1056 private: 1057 ring_buffer* fBuffer; 1058 }; 1059 1060 pager(TextSource(buffer)); 1061 1062 return true; 1063 } 1064 1065 1066 static status_t 1067 save_previous_syslog_to_volume(Directory* directory) 1068 { 1069 // find an unused name 1070 char name[16]; 1071 bool found = false; 1072 for (int i = 0; i < 99; i++) { 1073 snprintf(name, sizeof(name), "SYSLOG%02d.TXT", i); 1074 Node* node = directory->Lookup(name, false); 1075 if (node == NULL) { 1076 found = true; 1077 break; 1078 } 1079 1080 node->Release(); 1081 } 1082 1083 if (!found) { 1084 printf("Failed to find an unused name for the syslog file!\n"); 1085 return B_ERROR; 1086 } 1087 1088 printf("Writing syslog to file \"%s\" ...\n", name); 1089 1090 int fd = open_from(directory, name, O_RDWR | O_CREAT | O_EXCL, 0644); 1091 if (fd < 0) { 1092 printf("Failed to create syslog file!\n"); 1093 return fd; 1094 } 1095 1096 ring_buffer* syslogBuffer 1097 = (ring_buffer*)gKernelArgs.debug_output.Pointer(); 1098 iovec vecs[2]; 1099 int32 vecCount = ring_buffer_get_vecs(syslogBuffer, vecs); 1100 if (vecCount > 0) { 1101 size_t toWrite = ring_buffer_readable(syslogBuffer); 1102 1103 ssize_t written = writev(fd, vecs, vecCount); 1104 if (written < 0 || (size_t)written != toWrite) { 1105 printf("Failed to write to the syslog file \"%s\"!\n", name); 1106 close(fd); 1107 return errno; 1108 } 1109 } 1110 1111 close(fd); 1112 1113 printf("Successfully wrote syslog file.\n"); 1114 1115 return B_OK; 1116 } 1117 1118 1119 static bool 1120 debug_menu_add_advanced_option(Menu* menu, MenuItem* item) 1121 { 1122 char buffer[256]; 1123 1124 size_t size = platform_get_user_input_text(menu, item, buffer, 1125 sizeof(buffer) - 1); 1126 1127 if (size > 0) { 1128 buffer[size] = '\n'; 1129 if (!sSafeModeOptionsBuffer.Append(buffer)) { 1130 dprintf("debug_menu_add_advanced_option(): failed to append option " 1131 "to buffer\n"); 1132 } 1133 } 1134 1135 return true; 1136 } 1137 1138 1139 static bool 1140 debug_menu_toggle_debug_syslog(Menu* menu, MenuItem* item) 1141 { 1142 gKernelArgs.keep_debug_output_buffer = item->IsMarked(); 1143 return true; 1144 } 1145 1146 1147 static bool 1148 debug_menu_toggle_previous_debug_syslog(Menu* menu, MenuItem* item) 1149 { 1150 gKernelArgs.previous_debug_size = item->IsMarked(); 1151 return true; 1152 } 1153 1154 1155 static bool 1156 debug_menu_save_previous_syslog(Menu* menu, MenuItem* item) 1157 { 1158 Directory* volume = (Directory*)item->Data(); 1159 1160 console_clear_screen(); 1161 1162 save_previous_syslog_to_volume(volume); 1163 1164 printf("\nPress any key to continue\n"); 1165 console_wait_for_key(); 1166 1167 return true; 1168 } 1169 1170 1171 static void 1172 add_boot_volume_item(Menu* menu, Directory* volume, const char* name) 1173 { 1174 BReference<PackageVolumeInfo> volumeInfo; 1175 PackageVolumeState* selectedState = NULL; 1176 if (volume == sBootVolume->RootDirectory()) { 1177 volumeInfo.SetTo(sBootVolume->GetPackageVolumeInfo()); 1178 selectedState = sBootVolume->GetPackageVolumeState(); 1179 } else { 1180 volumeInfo.SetTo(new(std::nothrow) PackageVolumeInfo); 1181 if (volumeInfo->SetTo(volume, "system/packages") == B_OK) 1182 selectedState = volumeInfo->States().Head(); 1183 else 1184 volumeInfo.Unset(); 1185 } 1186 1187 BootVolumeMenuItem* item = new(nothrow) BootVolumeMenuItem(name); 1188 menu->AddItem(item); 1189 1190 Menu* subMenu = NULL; 1191 1192 if (volumeInfo != NULL) { 1193 subMenu = new(std::nothrow) Menu(CHOICE_MENU, "Select Haiku version"); 1194 1195 for (PackageVolumeStateList::ConstIterator it 1196 = volumeInfo->States().GetIterator(); 1197 PackageVolumeState* state = it.Next();) { 1198 PackageVolumeStateMenuItem* stateItem 1199 = new(nothrow) PackageVolumeStateMenuItem(state->DisplayName(), 1200 volumeInfo, state); 1201 subMenu->AddItem(stateItem); 1202 stateItem->SetTarget(user_menu_boot_volume_state); 1203 stateItem->SetData(volume); 1204 1205 if (state == selectedState) { 1206 stateItem->SetMarked(true); 1207 stateItem->Select(true); 1208 item->UpdateStateName(stateItem->VolumeState()); 1209 } 1210 } 1211 } 1212 1213 if (subMenu != NULL && subMenu->CountItems() > 1) { 1214 item->SetSubmenu(subMenu); 1215 } else { 1216 delete subMenu; 1217 item->SetTarget(user_menu_boot_volume); 1218 item->SetData(volume); 1219 } 1220 1221 if (volume == sBootVolume->RootDirectory()) { 1222 item->SetMarked(true); 1223 item->Select(true); 1224 } 1225 } 1226 1227 1228 static Menu* 1229 add_boot_volume_menu() 1230 { 1231 Menu* menu = new(std::nothrow) Menu(CHOICE_MENU, "Select Boot Volume"); 1232 MenuItem* item; 1233 void* cookie; 1234 int32 count = 0; 1235 1236 if (gRoot->Open(&cookie, O_RDONLY) == B_OK) { 1237 Directory* volume; 1238 while (gRoot->GetNextNode(cookie, (Node**)&volume) == B_OK) { 1239 // only list bootable volumes 1240 if (volume != sBootVolume->RootDirectory() && !is_bootable(volume)) 1241 continue; 1242 1243 char name[B_FILE_NAME_LENGTH]; 1244 if (volume->GetName(name, sizeof(name)) == B_OK) { 1245 add_boot_volume_item(menu, volume, name); 1246 1247 count++; 1248 } 1249 } 1250 gRoot->Close(cookie); 1251 } 1252 1253 if (count == 0) { 1254 // no boot volume found yet 1255 menu->AddItem(item = new(nothrow) MenuItem("<No boot volume found>")); 1256 item->SetType(MENU_ITEM_NO_CHOICE); 1257 item->SetEnabled(false); 1258 } 1259 1260 menu->AddSeparatorItem(); 1261 1262 menu->AddItem(item = new(nothrow) MenuItem("Rescan volumes")); 1263 item->SetHelpText("Please insert a Haiku CD-ROM or attach a USB disk - " 1264 "depending on your system, you can then boot from there."); 1265 item->SetType(MENU_ITEM_NO_CHOICE); 1266 if (count == 0) 1267 item->Select(true); 1268 1269 menu->AddItem(item = new(nothrow) MenuItem("Return to main menu")); 1270 item->SetType(MENU_ITEM_NO_CHOICE); 1271 1272 if (gBootVolume.GetBool(BOOT_VOLUME_BOOTED_FROM_IMAGE, false)) 1273 menu->SetChoiceText("CD-ROM or hard drive"); 1274 1275 return menu; 1276 } 1277 1278 1279 static Menu* 1280 add_safe_mode_menu() 1281 { 1282 Menu* safeMenu = new(nothrow) Menu(SAFE_MODE_MENU, "Safe Mode Options"); 1283 MenuItem* item; 1284 1285 safeMenu->AddItem(item = new(nothrow) MenuItem("Safe mode")); 1286 item->SetData(B_SAFEMODE_SAFE_MODE); 1287 item->SetType(MENU_ITEM_MARKABLE); 1288 item->SetHelpText("Puts the system into safe mode. This can be enabled " 1289 "independently from the other options."); 1290 1291 safeMenu->AddItem(item = new(nothrow) MenuItem("Disable user add-ons")); 1292 item->SetData(B_SAFEMODE_DISABLE_USER_ADD_ONS); 1293 item->SetType(MENU_ITEM_MARKABLE); 1294 item->SetHelpText("Prevents all user installed add-ons from being loaded. " 1295 "Only the add-ons in the system directory will be used."); 1296 1297 safeMenu->AddItem(item = new(nothrow) MenuItem("Disable IDE DMA")); 1298 item->SetData(B_SAFEMODE_DISABLE_IDE_DMA); 1299 item->SetType(MENU_ITEM_MARKABLE); 1300 item->SetHelpText("Disables IDE DMA, increasing IDE compatibility " 1301 "at the expense of performance."); 1302 1303 #if B_HAIKU_PHYSICAL_BITS > 32 1304 // check whether we have memory beyond 4 GB 1305 bool hasMemoryBeyond4GB = false; 1306 for (uint32 i = 0; i < gKernelArgs.num_physical_memory_ranges; i++) { 1307 addr_range& range = gKernelArgs.physical_memory_range[i]; 1308 if (range.start >= (uint64)1 << 32) { 1309 hasMemoryBeyond4GB = true; 1310 break; 1311 } 1312 } 1313 1314 bool needs64BitPaging = true; 1315 // TODO: Determine whether 64 bit paging (i.e. PAE for x86) is needed 1316 // for other reasons (NX support). 1317 1318 // ... add the menu item, if so 1319 if (hasMemoryBeyond4GB || needs64BitPaging) { 1320 safeMenu->AddItem( 1321 item = new(nothrow) MenuItem("Ignore memory beyond 4 GiB")); 1322 item->SetData(B_SAFEMODE_4_GB_MEMORY_LIMIT); 1323 item->SetType(MENU_ITEM_MARKABLE); 1324 item->SetHelpText("Ignores all memory beyond the 4 GiB address limit, " 1325 "overriding the setting in the kernel settings file."); 1326 } 1327 #endif 1328 1329 platform_add_menus(safeMenu); 1330 1331 safeMenu->AddSeparatorItem(); 1332 sBlacklistRootMenu = new(std::nothrow) BlacklistRootMenu; 1333 safeMenu->AddItem(item = new(std::nothrow) MenuItem("Blacklist entries", 1334 sBlacklistRootMenu)); 1335 item->SetHelpText("Allows to select system files that shall be ignored. " 1336 "Useful e.g. to disable drivers temporarily."); 1337 1338 safeMenu->AddSeparatorItem(); 1339 safeMenu->AddItem(item = new(nothrow) MenuItem("Return to main menu")); 1340 1341 return safeMenu; 1342 } 1343 1344 1345 static Menu* 1346 add_save_debug_syslog_menu() 1347 { 1348 Menu* menu = new(nothrow) Menu(STANDARD_MENU, "Save syslog to volume ..."); 1349 MenuItem* item; 1350 1351 const char* const kHelpText = "Currently only FAT32 volumes are supported. " 1352 "Newly plugged in removable devices are only recognized after " 1353 "rebooting."; 1354 1355 int32 itemsAdded = 0; 1356 1357 void* cookie; 1358 if (gRoot->Open(&cookie, O_RDONLY) == B_OK) { 1359 Node* node; 1360 while (gRoot->GetNextNode(cookie, &node) == B_OK) { 1361 Directory* volume = static_cast<Directory*>(node); 1362 Partition* partition; 1363 if (gRoot->GetPartitionFor(volume, &partition) != B_OK) 1364 continue; 1365 1366 // we support only FAT32 volumes ATM 1367 if (partition->content_type == NULL 1368 || strcmp(partition->content_type, kPartitionTypeFAT32) != 0) { 1369 continue; 1370 } 1371 1372 char name[B_FILE_NAME_LENGTH]; 1373 if (volume->GetName(name, sizeof(name)) != B_OK) 1374 strlcpy(name, "unnamed", sizeof(name)); 1375 1376 // append offset, size, and type to the name 1377 size_t len = strlen(name); 1378 char offsetBuffer[32]; 1379 char sizeBuffer[32]; 1380 snprintf(name + len, sizeof(name) - len, 1381 " (%s, offset %s, size %s)", partition->content_type, 1382 size_to_string(partition->offset, offsetBuffer, 1383 sizeof(offsetBuffer)), 1384 size_to_string(partition->size, sizeBuffer, 1385 sizeof(sizeBuffer))); 1386 1387 item = new(nothrow) MenuItem(name); 1388 item->SetData(volume); 1389 item->SetTarget(&debug_menu_save_previous_syslog); 1390 item->SetType(MENU_ITEM_NO_CHOICE); 1391 item->SetHelpText(kHelpText); 1392 menu->AddItem(item); 1393 itemsAdded++; 1394 } 1395 1396 gRoot->Close(cookie); 1397 } 1398 1399 if (itemsAdded == 0) { 1400 menu->AddItem(item 1401 = new(nothrow) MenuItem("No supported volumes found")); 1402 item->SetType(MENU_ITEM_NO_CHOICE); 1403 item->SetHelpText(kHelpText); 1404 item->SetEnabled(false); 1405 } 1406 1407 menu->AddSeparatorItem(); 1408 menu->AddItem(item = new(nothrow) MenuItem("Return to debug menu")); 1409 item->SetHelpText(kHelpText); 1410 1411 return menu; 1412 } 1413 1414 1415 static Menu* 1416 add_debug_menu() 1417 { 1418 Menu* menu = new(std::nothrow) Menu(STANDARD_MENU, "Debug Options"); 1419 MenuItem* item; 1420 1421 #if DEBUG_SPINLOCK_LATENCIES 1422 item = new(std::nothrow) MenuItem("Disable latency checks"); 1423 if (item != NULL) { 1424 item->SetType(MENU_ITEM_MARKABLE); 1425 item->SetData(B_SAFEMODE_DISABLE_LATENCY_CHECK); 1426 item->SetHelpText("Disables latency check panics."); 1427 menu->AddItem(item); 1428 } 1429 #endif 1430 1431 menu->AddItem(item 1432 = new(nothrow) MenuItem("Enable serial debug output")); 1433 item->SetData("serial_debug_output"); 1434 item->SetType(MENU_ITEM_MARKABLE); 1435 item->SetHelpText("Turns on forwarding the syslog output to the serial " 1436 "interface (default: 115200, 8N1)."); 1437 1438 menu->AddItem(item 1439 = new(nothrow) MenuItem("Enable on screen debug output")); 1440 item->SetData("debug_screen"); 1441 item->SetType(MENU_ITEM_MARKABLE); 1442 item->SetHelpText("Displays debug output on screen while the system " 1443 "is booting, instead of the normal boot logo."); 1444 1445 menu->AddItem(item 1446 = new(nothrow) MenuItem("Disable on screen paging")); 1447 item->SetData("disable_onscreen_paging"); 1448 item->SetType(MENU_ITEM_MARKABLE); 1449 item->SetHelpText("Disables paging when on screen debug output is " 1450 "enabled."); 1451 1452 menu->AddItem(item = new(nothrow) MenuItem("Enable debug syslog")); 1453 item->SetType(MENU_ITEM_MARKABLE); 1454 item->SetMarked(gKernelArgs.keep_debug_output_buffer); 1455 item->SetTarget(&debug_menu_toggle_debug_syslog); 1456 item->SetHelpText("Enables a special in-memory syslog buffer for this " 1457 "session that the boot loader will be able to access after rebooting."); 1458 1459 ring_buffer* syslogBuffer 1460 = (ring_buffer*)gKernelArgs.debug_output.Pointer(); 1461 bool hasPreviousSyslog 1462 = syslogBuffer != NULL && ring_buffer_readable(syslogBuffer) > 0; 1463 if (hasPreviousSyslog) { 1464 menu->AddItem(item = new(nothrow) MenuItem( 1465 "Save syslog from previous session during boot")); 1466 item->SetType(MENU_ITEM_MARKABLE); 1467 item->SetMarked(gKernelArgs.previous_debug_size); 1468 item->SetTarget(&debug_menu_toggle_previous_debug_syslog); 1469 item->SetHelpText("Saves the syslog from the previous Haiku session to " 1470 "/var/log/previous_syslog when booting."); 1471 } 1472 1473 bool currentLogItemVisible = platform_debug_get_log_buffer(NULL) != NULL; 1474 if (currentLogItemVisible) { 1475 menu->AddSeparatorItem(); 1476 menu->AddItem(item 1477 = new(nothrow) MenuItem("Display current boot loader log")); 1478 item->SetTarget(&debug_menu_display_current_log); 1479 item->SetType(MENU_ITEM_NO_CHOICE); 1480 item->SetHelpText( 1481 "Displays the debug info the boot loader has logged."); 1482 } 1483 1484 if (hasPreviousSyslog) { 1485 if (!currentLogItemVisible) 1486 menu->AddSeparatorItem(); 1487 1488 menu->AddItem(item 1489 = new(nothrow) MenuItem("Display syslog from previous session")); 1490 item->SetTarget(&debug_menu_display_previous_syslog); 1491 item->SetType(MENU_ITEM_NO_CHOICE); 1492 item->SetHelpText( 1493 "Displays the syslog from the previous Haiku session."); 1494 1495 menu->AddItem(item = new(nothrow) MenuItem( 1496 "Save syslog from previous session", add_save_debug_syslog_menu())); 1497 item->SetHelpText("Saves the syslog from the previous Haiku session to " 1498 "disk. Currently only FAT32 volumes are supported."); 1499 } 1500 1501 menu->AddSeparatorItem(); 1502 menu->AddItem(item = new(nothrow) MenuItem( 1503 "Add advanced debug option")); 1504 item->SetType(MENU_ITEM_NO_CHOICE); 1505 item->SetTarget(&debug_menu_add_advanced_option); 1506 item->SetHelpText( 1507 "Allows advanced debugging options to be entered directly."); 1508 1509 menu->AddSeparatorItem(); 1510 menu->AddItem(item = new(nothrow) MenuItem("Return to main menu")); 1511 1512 return menu; 1513 } 1514 1515 1516 static void 1517 apply_safe_mode_options(Menu* menu) 1518 { 1519 MenuItemIterator iterator = menu->ItemIterator(); 1520 while (MenuItem* item = iterator.Next()) { 1521 if (item->Type() == MENU_ITEM_SEPARATOR || !item->IsMarked() 1522 || item->Data() == NULL) { 1523 continue; 1524 } 1525 1526 char buffer[256]; 1527 if (snprintf(buffer, sizeof(buffer), "%s true\n", 1528 (const char*)item->Data()) >= (int)sizeof(buffer) 1529 || !sSafeModeOptionsBuffer.Append(buffer)) { 1530 dprintf("apply_safe_mode_options(): failed to append option to " 1531 "buffer\n"); 1532 } 1533 } 1534 } 1535 1536 1537 static void 1538 apply_safe_mode_path_blacklist() 1539 { 1540 if (sPathBlacklist->IsEmpty()) 1541 return; 1542 1543 bool success = sSafeModeOptionsBuffer.Append("EntryBlacklist {\n"); 1544 1545 for (PathBlacklist::Iterator it = sPathBlacklist->GetIterator(); 1546 BlacklistedPath* path = it.Next();) { 1547 success &= sSafeModeOptionsBuffer.Append(path->Path()); 1548 success &= sSafeModeOptionsBuffer.Append("\n", 1); 1549 } 1550 1551 success &= sSafeModeOptionsBuffer.Append("}\n"); 1552 1553 if (!success) { 1554 dprintf("apply_safe_mode_options(): failed to append path " 1555 "blacklist to buffer\n"); 1556 } 1557 } 1558 1559 1560 static bool 1561 user_menu_reboot(Menu* menu, MenuItem* item) 1562 { 1563 platform_exit(); 1564 return true; 1565 } 1566 1567 1568 status_t 1569 user_menu(BootVolume& _bootVolume, PathBlacklist& _pathBlacklist) 1570 { 1571 1572 Menu* menu = new(std::nothrow) Menu(MAIN_MENU); 1573 1574 sMainMenu = menu; 1575 sBootVolume = &_bootVolume; 1576 sPathBlacklist = &_pathBlacklist; 1577 1578 Menu* safeModeMenu = NULL; 1579 Menu* debugMenu = NULL; 1580 MenuItem* item; 1581 1582 TRACE(("user_menu: enter\n")); 1583 1584 // Add boot volume 1585 menu->AddItem(item = new(std::nothrow) MenuItem("Select boot volume", 1586 add_boot_volume_menu())); 1587 1588 // Add safe mode 1589 menu->AddItem(item = new(std::nothrow) MenuItem("Select safe mode options", 1590 safeModeMenu = add_safe_mode_menu())); 1591 1592 // add debug menu 1593 menu->AddItem(item = new(std::nothrow) MenuItem("Select debug options", 1594 debugMenu = add_debug_menu())); 1595 1596 // Add platform dependent menus 1597 platform_add_menus(menu); 1598 1599 menu->AddSeparatorItem(); 1600 1601 menu->AddItem(item = new(std::nothrow) MenuItem("Reboot")); 1602 item->SetTarget(user_menu_reboot); 1603 item->SetShortcut('r'); 1604 1605 menu->AddItem(item = new(std::nothrow) MenuItem("Continue booting")); 1606 if (!_bootVolume.IsValid()) { 1607 item->SetEnabled(false); 1608 menu->ItemAt(0)->Select(true); 1609 } else 1610 item->SetShortcut('b'); 1611 1612 menu->Run(); 1613 1614 apply_safe_mode_options(safeModeMenu); 1615 apply_safe_mode_options(debugMenu); 1616 apply_safe_mode_path_blacklist(); 1617 add_safe_mode_settings(sSafeModeOptionsBuffer.String()); 1618 delete menu; 1619 1620 1621 TRACE(("user_menu: leave\n")); 1622 1623 sMainMenu = NULL; 1624 sBlacklistRootMenu = NULL; 1625 sBootVolume = NULL; 1626 sPathBlacklist = NULL; 1627 return B_OK; 1628 } 1629