diff --git a/stand/lua/core.lua b/stand/lua/core.lua index 8a481ee0b782..718783309687 100644 --- a/stand/lua/core.lua +++ b/stand/lua/core.lua @@ -1,525 +1,516 @@ -- -- SPDX-License-Identifier: BSD-2-Clause -- -- Copyright (c) 2015 Pedro Souza -- Copyright (c) 2018 Kyle Evans -- All rights reserved. -- -- Redistribution and use in source and binary forms, with or without -- modification, are permitted provided that the following conditions -- are met: -- 1. Redistributions of source code must retain the above copyright -- notice, this list of conditions and the following disclaimer. -- 2. Redistributions in binary form must reproduce the above copyright -- notice, this list of conditions and the following disclaimer in the -- documentation and/or other materials provided with the distribution. -- -- THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND -- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE -- ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE -- FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -- DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS -- OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) -- HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT -- LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY -- OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF -- SUCH DAMAGE. -- local config = require("config") local hook = require("hook") local core = {} +local default_acpi = false local default_safe_mode = false local default_single_user = false local default_verbose = false local bootenv_list = "bootenvs" local function composeLoaderCmd(cmd_name, argstr) if argstr ~= nil then cmd_name = cmd_name .. " " .. argstr end return cmd_name end local function recordDefaults() - -- On i386, hint.acpi.0.rsdp will be set before we're loaded. On !i386, - -- it will generally be set upon execution of the kernel. Because of - -- this, we can't (or don't really want to) detect/disable ACPI on !i386 - -- reliably. Just set it enabled if we detect it and leave well enough - -- alone if we don't. - local boot_acpi = core.isSystem386() and core.getACPIPresent(false) local boot_single = loader.getenv("boot_single") or "no" local boot_verbose = loader.getenv("boot_verbose") or "no" + + default_acpi = core.getACPI() default_single_user = boot_single:lower() ~= "no" default_verbose = boot_verbose:lower() ~= "no" - if boot_acpi then - core.setACPI(true) - end + core.setACPI(default_acpi) core.setSingleUser(default_single_user) core.setVerbose(default_verbose) end -- Globals -- try_include will return the loaded module on success, or false and the error -- message on failure. function try_include(module) if module:sub(1, 1) ~= "/" then local lua_path = loader.lua_path -- XXX Temporary compat shim; this should be removed once the -- loader.lua_path export has sufficiently spread. if lua_path == nil then lua_path = "/boot/lua" end module = lua_path .. "/" .. module -- We only attempt to append an extension if an absolute path -- wasn't specified. This assumes that the caller either wants -- to treat this like it would require() and specify just the -- base filename, or they know what they're doing as they've -- specified an absolute path and we shouldn't impede. if module:match(".lua$") == nil then module = module .. ".lua" end end if lfs.attributes(module, "mode") ~= "file" then return end return dofile(module) end -- Module exports -- Commonly appearing constants core.KEY_BACKSPACE = 8 core.KEY_ENTER = 13 core.KEY_DELETE = 127 -- Note that this is a decimal representation, despite the leading 0 that in -- other contexts (outside of Lua) may mean 'octal' core.KEYSTR_ESCAPE = "\027" core.KEYSTR_CSI = core.KEYSTR_ESCAPE .. "[" core.KEYSTR_RESET = core.KEYSTR_ESCAPE .. "c" core.MENU_RETURN = "return" core.MENU_ENTRY = "entry" core.MENU_SEPARATOR = "separator" core.MENU_SUBMENU = "submenu" core.MENU_CAROUSEL_ENTRY = "carousel_entry" function core.setVerbose(verbose) if verbose == nil then verbose = not core.verbose end if verbose then loader.setenv("boot_verbose", "YES") else loader.unsetenv("boot_verbose") end core.verbose = verbose end function core.setSingleUser(single_user) if single_user == nil then single_user = not core.su end if single_user then loader.setenv("boot_single", "YES") else loader.unsetenv("boot_single") end core.su = single_user end -function core.getACPIPresent(checking_system_defaults) - local c = loader.getenv("hint.acpi.0.rsdp") +function core.hasACPI() + return loader.getenv("acpi.rsdp") ~= nil +end - if c ~= nil then - if checking_system_defaults then - return true - end - -- Otherwise, respect disabled if it's set - c = loader.getenv("hint.acpi.0.disabled") - return c == nil or tonumber(c) ~= 1 +function core.getACPI() + if not core.hasACPI() then + return false end - return false + + -- Otherwise, respect disabled if it's set + local c = loader.getenv("hint.acpi.0.disabled") + return c == nil or tonumber(c) ~= 1 end function core.setACPI(acpi) if acpi == nil then acpi = not core.acpi end if acpi then loader.setenv("acpi_load", "YES") loader.setenv("hint.acpi.0.disabled", "0") loader.unsetenv("loader.acpi_disabled_by_user") else loader.unsetenv("acpi_load") loader.setenv("hint.acpi.0.disabled", "1") loader.setenv("loader.acpi_disabled_by_user", "1") end core.acpi = acpi end function core.setSafeMode(safe_mode) if safe_mode == nil then safe_mode = not core.sm end if safe_mode then loader.setenv("kern.smp.disabled", "1") loader.setenv("hw.ata.ata_dma", "0") loader.setenv("hw.ata.atapi_dma", "0") loader.setenv("hw.ata.wc", "0") loader.setenv("hw.eisa_slots", "0") loader.setenv("kern.eventtimer.periodic", "1") loader.setenv("kern.geom.part.check_integrity", "0") else loader.unsetenv("kern.smp.disabled") loader.unsetenv("hw.ata.ata_dma") loader.unsetenv("hw.ata.atapi_dma") loader.unsetenv("hw.ata.wc") loader.unsetenv("hw.eisa_slots") loader.unsetenv("kern.eventtimer.periodic") loader.unsetenv("kern.geom.part.check_integrity") end core.sm = safe_mode end function core.clearCachedKernels() -- Clear the kernel cache on config changes, autodetect might have -- changed or if we've switched boot environments then we could have -- a new kernel set. core.cached_kernels = nil end function core.kernelList() if core.cached_kernels ~= nil then return core.cached_kernels end local k = loader.getenv("kernel") local v = loader.getenv("kernels") local autodetect = loader.getenv("kernels_autodetect") or "" local kernels = {} local unique = {} local i = 0 if k ~= nil then i = i + 1 kernels[i] = k unique[k] = true end if v ~= nil then for n in v:gmatch("([^;, ]+)[;, ]?") do if unique[n] == nil then i = i + 1 kernels[i] = n unique[n] = true end end end -- Do not attempt to autodetect if underlying filesystem -- do not support directory listing (e.g. tftp, http) if not lfs.attributes("/boot", "mode") then autodetect = "no" loader.setenv("kernels_autodetect", "NO") end -- Base whether we autodetect kernels or not on a loader.conf(5) -- setting, kernels_autodetect. If it's set to 'yes', we'll add -- any kernels we detect based on the criteria described. if autodetect:lower() ~= "yes" then core.cached_kernels = kernels return core.cached_kernels end -- Automatically detect other bootable kernel directories using a -- heuristic. Any directory in /boot that contains an ordinary file -- named "kernel" is considered eligible. for file, ftype in lfs.dir("/boot") do local fname = "/boot/" .. file if file == "." or file == ".." then goto continue end if ftype then if ftype ~= lfs.DT_DIR then goto continue end elseif lfs.attributes(fname, "mode") ~= "directory" then goto continue end if lfs.attributes(fname .. "/kernel", "mode") ~= "file" then goto continue end if unique[file] == nil then i = i + 1 kernels[i] = file unique[file] = true end ::continue:: end core.cached_kernels = kernels return core.cached_kernels end function core.bootenvDefault() return loader.getenv("zfs_be_active") end function core.bootenvList() local bootenv_count = tonumber(loader.getenv(bootenv_list .. "_count")) local bootenvs = {} local curenv local envcount = 0 local unique = {} if bootenv_count == nil or bootenv_count <= 0 then return bootenvs end -- Currently selected bootenv is always first/default -- On the rewinded list the bootenv may not exists if core.isRewinded() then curenv = core.bootenvDefaultRewinded() else curenv = core.bootenvDefault() end if curenv ~= nil then envcount = envcount + 1 bootenvs[envcount] = curenv unique[curenv] = true end for curenv_idx = 0, bootenv_count - 1 do curenv = loader.getenv(bootenv_list .. "[" .. curenv_idx .. "]") if curenv ~= nil and unique[curenv] == nil then envcount = envcount + 1 bootenvs[envcount] = curenv unique[curenv] = true end end return bootenvs end function core.isCheckpointed() return loader.getenv("zpool_checkpoint") ~= nil end function core.bootenvDefaultRewinded() local defname = "zfs:!" .. string.sub(core.bootenvDefault(), 5) local bootenv_count = tonumber("bootenvs_check_count") if bootenv_count == nil or bootenv_count <= 0 then return defname end for curenv_idx = 0, bootenv_count - 1 do local curenv = loader.getenv("bootenvs_check[" .. curenv_idx .. "]") if curenv == defname then return defname end end return loader.getenv("bootenvs_check[0]") end function core.isRewinded() return bootenv_list == "bootenvs_check" end function core.changeRewindCheckpoint() if core.isRewinded() then bootenv_list = "bootenvs" else bootenv_list = "bootenvs_check" end end function core.loadEntropy() if core.isUEFIBoot() then if (loader.getenv("entropy_efi_seed") or "no"):lower() == "yes" then loader.perform("efi-seed-entropy") end end end function core.setDefaults() - core.setACPI(core.getACPIPresent(true)) + core.setACPI(default_acpi) core.setSafeMode(default_safe_mode) core.setSingleUser(default_single_user) core.setVerbose(default_verbose) end function core.autoboot(argstr) -- loadelf() only if we've not already loaded a kernel if loader.getenv("kernelname") == nil then config.loadelf() end core.loadEntropy() loader.perform(composeLoaderCmd("autoboot", argstr)) end function core.boot(argstr) -- loadelf() only if we've not already loaded a kernel if loader.getenv("kernelname") == nil then config.loadelf() end core.loadEntropy() loader.perform(composeLoaderCmd("boot", argstr)) end function core.isSingleUserBoot() local single_user = loader.getenv("boot_single") return single_user ~= nil and single_user:lower() == "yes" end function core.isUEFIBoot() local efiver = loader.getenv("efi-version") return efiver ~= nil end function core.isZFSBoot() local c = loader.getenv("currdev") if c ~= nil then return c:match("^zfs:") ~= nil end return false end function core.isFramebufferConsole() local c = loader.getenv("console") if c ~= nil then if c:find("efi") == nil and c:find("vidconsole") == nil then return false end if loader.getenv("screen.depth") ~= nil then return true end end return false end function core.isSerialConsole() local c = loader.getenv("console") if c ~= nil then -- serial console is comconsole, but also userboot. -- userboot is there, because we have no way to know -- if the user terminal can draw unicode box chars or not. if c:find("comconsole") ~= nil or c:find("userboot") ~= nil then return true end end return false end function core.isSerialBoot() local s = loader.getenv("boot_serial") if s ~= nil then return true end local m = loader.getenv("boot_multicons") if m ~= nil then return true end return false end -function core.isSystem386() - return loader.machine_arch == "i386" -end - -- Is the menu skipped in the environment in which we've booted? function core.isMenuSkipped() return string.lower(loader.getenv("beastie_disable") or "") == "yes" end -- This may be a better candidate for a 'utility' module. function core.deepCopyTable(tbl) local new_tbl = {} for k, v in pairs(tbl) do if type(v) == "table" then new_tbl[k] = core.deepCopyTable(v) else new_tbl[k] = v end end return new_tbl end -- XXX This should go away if we get the table lib into shape for importing. -- As of now, it requires some 'os' functions, so we'll implement this in lua -- for our uses function core.popFrontTable(tbl) -- Shouldn't reasonably happen if #tbl == 0 then return nil, nil elseif #tbl == 1 then return tbl[1], {} end local first_value = tbl[1] local new_tbl = {} -- This is not a cheap operation for k, v in ipairs(tbl) do if k > 1 then new_tbl[k - 1] = v end end return first_value, new_tbl end function core.getConsoleName() if loader.getenv("boot_multicons") ~= nil then if loader.getenv("boot_serial") ~= nil then return "Dual (Serial primary)" else return "Dual (Video primary)" end else if loader.getenv("boot_serial") ~= nil then return "Serial" else return "Video" end end end function core.nextConsoleChoice() if loader.getenv("boot_multicons") ~= nil then if loader.getenv("boot_serial") ~= nil then loader.unsetenv("boot_serial") else loader.unsetenv("boot_multicons") loader.setenv("boot_serial", "YES") end else if loader.getenv("boot_serial") ~= nil then loader.unsetenv("boot_serial") else loader.setenv("boot_multicons", "YES") loader.setenv("boot_serial", "YES") end end end recordDefaults() hook.register("config.reloaded", core.clearCachedKernels) return core diff --git a/stand/lua/core.lua.8 b/stand/lua/core.lua.8 index 39ae2166d442..61eab6fe24f6 100644 --- a/stand/lua/core.lua.8 +++ b/stand/lua/core.lua.8 @@ -1,231 +1,227 @@ .\" .\" SPDX-License-Identifier: BSD-2-Clause .\" .\" Copyright (c) 2018 Kyle Evans .\" .\" Redistribution and use in source and binary forms, with or without .\" modification, are permitted provided that the following conditions .\" are met: .\" 1. Redistributions of source code must retain the above copyright .\" notice, this list of conditions and the following disclaimer. .\" 2. Redistributions in binary form must reproduce the above copyright .\" notice, this list of conditions and the following disclaimer in the .\" documentation and/or other materials provided with the distribution. .\" .\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND .\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE .\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE .\" ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE .\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF .\" SUCH DAMAGE. .\" -.Dd March 21, 2018 +.Dd November 20, 2023 .Dt CORE.LUA 8 .Os .Sh NAME .Nm core.lua .Nd FreeBSD core module .Sh DESCRIPTION .Nm contains core functionality that does not have a more fitting module. .Pp Before hooking into or using the functionality provided by .Nm , it must be included with a statement such as the following: .Pp .Dl local core = require("core") .Ss CONSTANTS The following raw key code constants are defined in .Nm : .Bl -tag -width KEY_BACKSPACE -compact -offset indent .It Ic KEY_BACKSPACE The backspace code. Should generally be checked along with .Ic KEY_DELETE for backspace functionality. .It Ic KEY_ENTER The enter key, or hard return. .It Ic KEY_DELETE The delete code. Should generally be checked along with .Ic KEY_BACKSPACE for backspace functionality. .El .Pp The following key-string constants are defined in .Nm : .Bl -tag -width KEYSTR_ESCAPE -compact -offset indent .It Ic KEYSTR_ESCAPE The escape key. .It Ic KEYSTR_CSI The ANSI CSI sequence. .El .Pp The following menu entry type constants are defined in .Nm : .Bl -tag -width MENU_CAROUSEL_ENTRY -compact -offset indent .It Ic MENU_RETURN Return to the parent menu. .It Ic MENU_ENTRY A normal menu entry. .It Ic MENU_SEPARATOR A menu entry that serves as a separator. .It Ic MENU_SUBMENU A menu entry that opens a submenu when selected. .It Ic MENU_CAROUSEL_ENTRY A menu entry that rotates through items like a carousel upon selection of the menu entry. .El .Pp Please see .Xr menu.lua 8 for extended descriptions and usage of the .Ic MENU_* constants. .Ss Exported functions The following functions are exported from .Nm : -.Bl -tag -width core.getACPIPresent -offset indent +.Bl -tag -width core.setSingleUser -offset indent .It Fn core.setVerbose verbose Sets or unsets .Ev boot_verbose . If .Fa verbose is omitted, toggle the current verbose setting. .It Fn core.setSingleUser singleUser Sets or unsets .Ev boot_single . If .Fa singleUser is omitted, toggle the current single user setting. -.It Fn core.getACPIPresent checkingSystemDefaults -Check whether ACPI is present. -This will only be accurate for i386-compatible loaders, including non-UEFI -loaders on amd64 systems. -If -.Fa checkingSystemDefaults -is true, ignore the current value of -.Ev hint.acpi.0.disabled . -Otherwise, return true only if ACPI is both present and not disabled. +.It Fn core.getACPI +Return true if ACPI is both present and not explicitly disabled by +.Ev hints.acpi.0.disabled . +.It Fn core.hasACPI +Checks whether ACPI support is present. +This requires the loader to probe the system and set +.Ev acpi.rsdp +early before starting the interpreter. .It Fn core.setACPI acpi Sets or unsets .Ev acpi_load , .Ev hint.acpi.0.disabled , and .Ev loader.acpi_disabled_by_user . If .Fa acpi is omitted, toggle the current ACPI setting. .It Fn core.setSafeMode safeMode Set the safe mode setting. Sets or unsets .Ev kern.smp.disabled , .Ev hw.ata.ata_dma , .Ev hw.ata.atapi_dma , .Ev hw.ata.wc , .Ev hw.eisa_slots , .Ev kern.eventtimer.periodic , and .Ev kern.geom.part.check_integrity . If .Fa safeMode is omitted, toggle the current safe mode setting. .It Fn core.clearCachedKernels Clears out the cache of kernels to be displayed on the boot menu. This function is registered as a .Ev config.reloaded hook. It is used to invalidate the kernel list whenever it may have changed, either due to a boot environment change or a potential change in either .Ic kernel or .Ic kernels . .It Fn core.kernelList Returns a table of kernels to display on the boot menu. This will combine .Ic kernel and .Ic kernels from .Xr loader.conf 5 . If .Ic kernels_autodetect is set in .Xr loader.conf 5 , kernels will be autodetected from the current system. .It Fn core.bootenvDefault Returns the default boot environment, nil if unset. .It Fn core.bootenvList Returns a table of boot environments, or an empty table. These will be picked up using the .Ev bootenvs and .Ev bootenvs_count variables set by .Xr loader 8 . .It Fn core.setDefaults Resets ACPI, safe mode, single user, and verbose settings to their system defauilts. .It Fn core.autoboot argstr Loads the kernel and specified modules, then invokes the .Ic autoboot .Xr loader 8 command with .Fa argstr as-is. .It Fn core.boot argstr Loads the kernel and specified modules, then invokes the .Ic boot .Xr loader 8 command with .Fa argstr as-is. .It Fn core.isSingleUserBoot Returns true if .Ev boot_single is set to yes. .It Fn core.isZFSBoot Returns true if .Ev currdev is set to a .Xr zfs 8 dataset. .It Fn core.isSerialBoot Returns true if we are booting over serial. This checks .Ev console , .Ev boot_serial , and .Ev boot_multicons . -.It Fn core.isSystem386 -Returns true if this bootloader was compiled as an i386 binary. -This generally applies to i386 loaders as well as non-UEFI loaders on amd64. .It Fn core.deepCopyTable tbl Recursively deep copies .Fa tbl and returns the result. .It Fn core.popFrontTable tbl Pops the front element off of .Fa tbl , and returns two return values: the front element, and the rest of the table. If there are no elements, this returns nil and nil. If there is one element, this returns the front element and an empty table. This will not operate on truly associative tables; numeric indices are required. .El .Sh SEE ALSO .Xr loader.conf 5 , .Xr loader 8 , .Xr menu.lua 8 .Sh AUTHORS The .Nm file was originally written by .An Pedro Souza Aq Mt pedrosouza@FreeBSD.org . Later work and this manual page was done by .An Kyle Evans Aq Mt kevans@FreeBSD.org . diff --git a/stand/lua/menu.lua b/stand/lua/menu.lua index 7da03ad9e673..4a948acf8241 100644 --- a/stand/lua/menu.lua +++ b/stand/lua/menu.lua @@ -1,564 +1,564 @@ -- -- SPDX-License-Identifier: BSD-2-Clause -- -- Copyright (c) 2015 Pedro Souza -- Copyright (c) 2018 Kyle Evans -- All rights reserved. -- -- Redistribution and use in source and binary forms, with or without -- modification, are permitted provided that the following conditions -- are met: -- 1. Redistributions of source code must retain the above copyright -- notice, this list of conditions and the following disclaimer. -- 2. Redistributions in binary form must reproduce the above copyright -- notice, this list of conditions and the following disclaimer in the -- documentation and/or other materials provided with the distribution. -- -- THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND -- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE -- ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE -- FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -- DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS -- OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) -- HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT -- LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY -- OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF -- SUCH DAMAGE. -- local cli = require("cli") local core = require("core") local color = require("color") local config = require("config") local screen = require("screen") local drawer = require("drawer") local menu = {} local drawn_menu local return_menu_entry = { entry_type = core.MENU_RETURN, name = "Back to main menu" .. color.highlight(" [Backspace]"), } local function OnOff(str, value) if value then return str .. color.escapefg(color.GREEN) .. "On" .. color.resetfg() else return str .. color.escapefg(color.RED) .. "off" .. color.resetfg() end end local function bootenvSet(env) loader.setenv("vfs.root.mountfrom", env) loader.setenv("currdev", env .. ":") config.reload() if loader.getenv("kernelname") ~= nil then loader.perform("unload") end end local function multiUserPrompt() return loader.getenv("loader_menu_multi_user_prompt") or "Multi user" end -- Module exports menu.handlers = { -- Menu handlers take the current menu and selected entry as parameters, -- and should return a boolean indicating whether execution should -- continue or not. The return value may be omitted if this entry should -- have no bearing on whether we continue or not, indicating that we -- should just continue after execution. [core.MENU_ENTRY] = function(_, entry) -- run function entry.func() end, [core.MENU_CAROUSEL_ENTRY] = function(_, entry) -- carousel (rotating) functionality local carid = entry.carousel_id local caridx = config.getCarouselIndex(carid) local choices = entry.items if type(choices) == "function" then choices = choices() end if #choices > 0 then caridx = (caridx % #choices) + 1 config.setCarouselIndex(carid, caridx) entry.func(caridx, choices[caridx], choices) end end, [core.MENU_SUBMENU] = function(_, entry) menu.process(entry.submenu) end, [core.MENU_RETURN] = function(_, entry) -- allow entry to have a function/side effect if entry.func ~= nil then entry.func() end return false end, } -- loader menu tree is rooted at menu.welcome menu.boot_environments = { entries = { -- return to welcome menu return_menu_entry, { entry_type = core.MENU_CAROUSEL_ENTRY, carousel_id = "be_active", items = core.bootenvList, name = function(idx, choice, all_choices) if #all_choices == 0 then return "Active: " end local is_default = (idx == 1) local bootenv_name = "" local name_color if is_default then name_color = color.escapefg(color.GREEN) else name_color = color.escapefg(color.BLUE) end bootenv_name = bootenv_name .. name_color .. choice .. color.resetfg() return color.highlight("A").."ctive: " .. bootenv_name .. " (" .. idx .. " of " .. #all_choices .. ")" end, func = function(_, choice, _) bootenvSet(choice) end, alias = {"a", "A"}, }, { entry_type = core.MENU_ENTRY, visible = function() return core.isRewinded() == false end, name = function() return color.highlight("b") .. "ootfs: " .. core.bootenvDefault() end, func = function() -- Reset active boot environment to the default config.setCarouselIndex("be_active", 1) bootenvSet(core.bootenvDefault()) end, alias = {"b", "B"}, }, }, } menu.boot_options = { entries = { -- return to welcome menu return_menu_entry, -- load defaults { entry_type = core.MENU_ENTRY, name = "Load System " .. color.highlight("D") .. "efaults", func = core.setDefaults, alias = {"d", "D"}, }, { entry_type = core.MENU_SEPARATOR, }, { entry_type = core.MENU_SEPARATOR, name = "Boot Options:", }, -- acpi { entry_type = core.MENU_ENTRY, - visible = core.isSystem386, + visible = core.hasACPI, name = function() return OnOff(color.highlight("A") .. "CPI :", core.acpi) end, func = core.setACPI, alias = {"a", "A"}, }, -- safe mode { entry_type = core.MENU_ENTRY, name = function() return OnOff("Safe " .. color.highlight("M") .. "ode :", core.sm) end, func = core.setSafeMode, alias = {"m", "M"}, }, -- single user { entry_type = core.MENU_ENTRY, name = function() return OnOff(color.highlight("S") .. "ingle user:", core.su) end, func = core.setSingleUser, alias = {"s", "S"}, }, -- verbose boot { entry_type = core.MENU_ENTRY, name = function() return OnOff(color.highlight("V") .. "erbose :", core.verbose) end, func = core.setVerbose, alias = {"v", "V"}, }, }, } menu.welcome = { entries = function() local menu_entries = menu.welcome.all_entries local multi_user = menu_entries.multi_user local single_user = menu_entries.single_user local boot_entry_1, boot_entry_2 if core.isSingleUserBoot() then -- Swap the first two menu items on single user boot. -- We'll cache the alternate entries for performance. local alts = menu_entries.alts if alts == nil then single_user = core.deepCopyTable(single_user) multi_user = core.deepCopyTable(multi_user) single_user.name = single_user.alternate_name multi_user.name = multi_user.alternate_name menu_entries.alts = { single_user = single_user, multi_user = multi_user, } else single_user = alts.single_user multi_user = alts.multi_user end boot_entry_1, boot_entry_2 = single_user, multi_user else boot_entry_1, boot_entry_2 = multi_user, single_user end return { boot_entry_1, boot_entry_2, menu_entries.prompt, menu_entries.reboot, menu_entries.console, { entry_type = core.MENU_SEPARATOR, }, { entry_type = core.MENU_SEPARATOR, name = "Options:", }, menu_entries.kernel_options, menu_entries.boot_options, menu_entries.zpool_checkpoints, menu_entries.boot_envs, menu_entries.chainload, menu_entries.vendor, } end, all_entries = { multi_user = { entry_type = core.MENU_ENTRY, name = function() return color.highlight("B") .. "oot " .. multiUserPrompt() .. " " .. color.highlight("[Enter]") end, -- Not a standard menu entry function! alternate_name = function() return color.highlight("B") .. "oot " .. multiUserPrompt() end, func = function() core.setSingleUser(false) core.boot() end, alias = {"b", "B"}, }, single_user = { entry_type = core.MENU_ENTRY, name = "Boot " .. color.highlight("S") .. "ingle user", -- Not a standard menu entry function! alternate_name = "Boot " .. color.highlight("S") .. "ingle user " .. color.highlight("[Enter]"), func = function() core.setSingleUser(true) core.boot() end, alias = {"s", "S"}, }, console = { entry_type = core.MENU_ENTRY, name = function() return color.highlight("C") .. "ons: " .. core.getConsoleName() end, func = function() core.nextConsoleChoice() end, alias = {"c", "C"}, }, prompt = { entry_type = core.MENU_RETURN, name = color.highlight("Esc") .. "ape to loader prompt", func = function() loader.setenv("autoboot_delay", "NO") end, alias = {core.KEYSTR_ESCAPE}, }, reboot = { entry_type = core.MENU_ENTRY, name = color.highlight("R") .. "eboot", func = function() loader.perform("reboot") end, alias = {"r", "R"}, }, kernel_options = { entry_type = core.MENU_CAROUSEL_ENTRY, carousel_id = "kernel", items = core.kernelList, name = function(idx, choice, all_choices) if #all_choices == 0 then return "Kernel: " end local is_default = (idx == 1) local kernel_name = "" local name_color if is_default then name_color = color.escapefg(color.GREEN) kernel_name = "default/" else name_color = color.escapefg(color.BLUE) end kernel_name = kernel_name .. name_color .. choice .. color.resetfg() return color.highlight("K") .. "ernel: " .. kernel_name .. " (" .. idx .. " of " .. #all_choices .. ")" end, func = function(_, choice, _) if loader.getenv("kernelname") ~= nil then loader.perform("unload") end config.selectKernel(choice) end, alias = {"k", "K"}, }, boot_options = { entry_type = core.MENU_SUBMENU, name = "Boot " .. color.highlight("O") .. "ptions", submenu = menu.boot_options, alias = {"o", "O"}, }, zpool_checkpoints = { entry_type = core.MENU_ENTRY, name = function() local rewind = "No" if core.isRewinded() then rewind = "Yes" end return "Rewind ZFS " .. color.highlight("C") .. "heckpoint: " .. rewind end, func = function() core.changeRewindCheckpoint() if core.isRewinded() then bootenvSet( core.bootenvDefaultRewinded()) else bootenvSet(core.bootenvDefault()) end config.setCarouselIndex("be_active", 1) end, visible = function() return core.isZFSBoot() and core.isCheckpointed() end, alias = {"c", "C"}, }, boot_envs = { entry_type = core.MENU_SUBMENU, visible = function() return core.isZFSBoot() and #core.bootenvList() > 1 end, name = "Boot " .. color.highlight("E") .. "nvironments", submenu = menu.boot_environments, alias = {"e", "E"}, }, chainload = { entry_type = core.MENU_ENTRY, name = function() return 'Chain' .. color.highlight("L") .. "oad " .. loader.getenv('chain_disk') end, func = function() loader.perform("chain " .. loader.getenv('chain_disk')) end, visible = function() return loader.getenv('chain_disk') ~= nil end, alias = {"l", "L"}, }, vendor = { entry_type = core.MENU_ENTRY, visible = function() return false end }, }, } menu.default = menu.welcome -- current_alias_table will be used to keep our alias table consistent across -- screen redraws, instead of relying on whatever triggered the redraw to update -- the local alias_table in menu.process. menu.current_alias_table = {} function menu.draw(menudef) -- Clear the screen, reset the cursor, then draw screen.clear() menu.current_alias_table = drawer.drawscreen(menudef) drawn_menu = menudef screen.defcursor() end -- 'keypress' allows the caller to indicate that a key has been pressed that we -- should process as our initial input. function menu.process(menudef, keypress) assert(menudef ~= nil) if drawn_menu ~= menudef then menu.draw(menudef) end while true do local key = keypress or io.getchar() keypress = nil -- Special key behaviors if (key == core.KEY_BACKSPACE or key == core.KEY_DELETE) and menudef ~= menu.default then break elseif key == core.KEY_ENTER then core.boot() -- Should not return. If it does, escape menu handling -- and drop to loader prompt. return false end key = string.char(key) -- check to see if key is an alias local sel_entry = nil for k, v in pairs(menu.current_alias_table) do if key == k then sel_entry = v break end end -- if we have an alias do the assigned action: if sel_entry ~= nil then local handler = menu.handlers[sel_entry.entry_type] assert(handler ~= nil) -- The handler's return value indicates if we -- need to exit this menu. An omitted or true -- return value means to continue. if handler(menudef, sel_entry) == false then return end -- If we got an alias key the screen is out of date... -- redraw it. menu.draw(menudef) end end end function menu.run() local autoboot_key local delay = loader.getenv("autoboot_delay") if delay ~= nil and delay:lower() == "no" then delay = nil else delay = tonumber(delay) or 10 end if delay == -1 then core.boot() return end menu.draw(menu.default) if delay ~= nil then autoboot_key = menu.autoboot(delay) -- autoboot_key should return the key pressed. It will only -- return nil if we hit the timeout and executed the timeout -- command. Bail out. if autoboot_key == nil then return end end menu.process(menu.default, autoboot_key) drawn_menu = nil screen.defcursor() print("Exiting menu!") end function menu.autoboot(delay) local x = loader.getenv("loader_menu_timeout_x") or 4 local y = loader.getenv("loader_menu_timeout_y") or 23 local endtime = loader.time() + delay local time local last repeat time = endtime - loader.time() if last == nil or last ~= time then last = time screen.setcursor(x, y) print("Autoboot in " .. time .. " seconds. [Space] to pause ") screen.defcursor() end if io.ischar() then local ch = io.getchar() if ch == core.KEY_ENTER then break else -- erase autoboot msg screen.setcursor(0, y) print(string.rep(" ", 80)) screen.defcursor() return ch end end loader.delay(50000) until time <= 0 local cmd = loader.getenv("menu_timeout_command") or "boot" cli_execute_unparsed(cmd) return nil end -- CLI commands function cli.menu() menu.run() end return menu