]> CyberLeo.Net >> Repos - FreeBSD/FreeBSD.git/blob - stand/lua/core.lua
contrib/tzdata: import tzdata 2022a
[FreeBSD/FreeBSD.git] / stand / lua / core.lua
1 --
2 -- SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3 --
4 -- Copyright (c) 2015 Pedro Souza <pedrosouza@freebsd.org>
5 -- Copyright (c) 2018 Kyle Evans <kevans@FreeBSD.org>
6 -- All rights reserved.
7 --
8 -- Redistribution and use in source and binary forms, with or without
9 -- modification, are permitted provided that the following conditions
10 -- are met:
11 -- 1. Redistributions of source code must retain the above copyright
12 --    notice, this list of conditions and the following disclaimer.
13 -- 2. Redistributions in binary form must reproduce the above copyright
14 --    notice, this list of conditions and the following disclaimer in the
15 --    documentation and/or other materials provided with the distribution.
16 --
17 -- THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18 -- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 -- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 -- ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21 -- FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 -- DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 -- OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 -- HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 -- LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 -- OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 -- SUCH DAMAGE.
28 --
29 -- $FreeBSD$
30 --
31
32 local config = require("config")
33 local hook = require("hook")
34
35 local core = {}
36
37 local default_safe_mode = false
38 local default_single_user = false
39 local default_verbose = false
40
41 local bootenv_list = "bootenvs"
42
43 local function composeLoaderCmd(cmd_name, argstr)
44         if argstr ~= nil then
45                 cmd_name = cmd_name .. " " .. argstr
46         end
47         return cmd_name
48 end
49
50 local function recordDefaults()
51         -- On i386, hint.acpi.0.rsdp will be set before we're loaded. On !i386,
52         -- it will generally be set upon execution of the kernel. Because of
53         -- this, we can't (or don't really want to) detect/disable ACPI on !i386
54         -- reliably. Just set it enabled if we detect it and leave well enough
55         -- alone if we don't.
56         local boot_acpi = core.isSystem386() and core.getACPIPresent(false)
57         local boot_single = loader.getenv("boot_single") or "no"
58         local boot_verbose = loader.getenv("boot_verbose") or "no"
59         default_single_user = boot_single:lower() ~= "no"
60         default_verbose = boot_verbose:lower() ~= "no"
61
62         if boot_acpi then
63                 core.setACPI(true)
64         end
65         core.setSingleUser(default_single_user)
66         core.setVerbose(default_verbose)
67 end
68
69
70 -- Globals
71 -- try_include will return the loaded module on success, or false and the error
72 -- message on failure.
73 function try_include(module)
74         if module:sub(1, 1) ~= "/" then
75                 local lua_path = loader.lua_path
76                 -- XXX Temporary compat shim; this should be removed once the
77                 -- loader.lua_path export has sufficiently spread.
78                 if lua_path == nil then
79                         lua_path = "/boot/lua"
80                 end
81                 module = lua_path .. "/" .. module
82                 -- We only attempt to append an extension if an absolute path
83                 -- wasn't specified.  This assumes that the caller either wants
84                 -- to treat this like it would require() and specify just the
85                 -- base filename, or they know what they're doing as they've
86                 -- specified an absolute path and we shouldn't impede.
87                 if module:match(".lua$") == nil then
88                         module = module .. ".lua"
89                 end
90         end
91         if lfs.attributes(module, "mode") ~= "file" then
92                 return
93         end
94
95         return dofile(module)
96 end
97
98 -- Module exports
99 -- Commonly appearing constants
100 core.KEY_BACKSPACE      = 8
101 core.KEY_ENTER          = 13
102 core.KEY_DELETE         = 127
103
104 -- Note that this is a decimal representation, despite the leading 0 that in
105 -- other contexts (outside of Lua) may mean 'octal'
106 core.KEYSTR_ESCAPE      = "\027"
107 core.KEYSTR_CSI         = core.KEYSTR_ESCAPE .. "["
108 core.KEYSTR_RESET       = core.KEYSTR_ESCAPE .. "c"
109
110 core.MENU_RETURN        = "return"
111 core.MENU_ENTRY         = "entry"
112 core.MENU_SEPARATOR     = "separator"
113 core.MENU_SUBMENU       = "submenu"
114 core.MENU_CAROUSEL_ENTRY        = "carousel_entry"
115
116 function core.setVerbose(verbose)
117         if verbose == nil then
118                 verbose = not core.verbose
119         end
120
121         if verbose then
122                 loader.setenv("boot_verbose", "YES")
123         else
124                 loader.unsetenv("boot_verbose")
125         end
126         core.verbose = verbose
127 end
128
129 function core.setSingleUser(single_user)
130         if single_user == nil then
131                 single_user = not core.su
132         end
133
134         if single_user then
135                 loader.setenv("boot_single", "YES")
136         else
137                 loader.unsetenv("boot_single")
138         end
139         core.su = single_user
140 end
141
142 function core.getACPIPresent(checking_system_defaults)
143         local c = loader.getenv("hint.acpi.0.rsdp")
144
145         if c ~= nil then
146                 if checking_system_defaults then
147                         return true
148                 end
149                 -- Otherwise, respect disabled if it's set
150                 c = loader.getenv("hint.acpi.0.disabled")
151                 return c == nil or tonumber(c) ~= 1
152         end
153         return false
154 end
155
156 function core.setACPI(acpi)
157         if acpi == nil then
158                 acpi = not core.acpi
159         end
160
161         if acpi then
162                 loader.setenv("acpi_load", "YES")
163                 loader.setenv("hint.acpi.0.disabled", "0")
164                 loader.unsetenv("loader.acpi_disabled_by_user")
165         else
166                 loader.unsetenv("acpi_load")
167                 loader.setenv("hint.acpi.0.disabled", "1")
168                 loader.setenv("loader.acpi_disabled_by_user", "1")
169         end
170         core.acpi = acpi
171 end
172
173 function core.setSafeMode(safe_mode)
174         if safe_mode == nil then
175                 safe_mode = not core.sm
176         end
177         if safe_mode then
178                 loader.setenv("kern.smp.disabled", "1")
179                 loader.setenv("hw.ata.ata_dma", "0")
180                 loader.setenv("hw.ata.atapi_dma", "0")
181                 loader.setenv("hw.ata.wc", "0")
182                 loader.setenv("hw.eisa_slots", "0")
183                 loader.setenv("kern.eventtimer.periodic", "1")
184                 loader.setenv("kern.geom.part.check_integrity", "0")
185         else
186                 loader.unsetenv("kern.smp.disabled")
187                 loader.unsetenv("hw.ata.ata_dma")
188                 loader.unsetenv("hw.ata.atapi_dma")
189                 loader.unsetenv("hw.ata.wc")
190                 loader.unsetenv("hw.eisa_slots")
191                 loader.unsetenv("kern.eventtimer.periodic")
192                 loader.unsetenv("kern.geom.part.check_integrity")
193         end
194         core.sm = safe_mode
195 end
196
197 function core.clearCachedKernels()
198         -- Clear the kernel cache on config changes, autodetect might have
199         -- changed or if we've switched boot environments then we could have
200         -- a new kernel set.
201         core.cached_kernels = nil
202 end
203
204 function core.kernelList()
205         if core.cached_kernels ~= nil then
206                 return core.cached_kernels
207         end
208
209         local k = loader.getenv("kernel")
210         local v = loader.getenv("kernels")
211         local autodetect = loader.getenv("kernels_autodetect") or ""
212
213         local kernels = {}
214         local unique = {}
215         local i = 0
216         if k ~= nil then
217                 i = i + 1
218                 kernels[i] = k
219                 unique[k] = true
220         end
221
222         if v ~= nil then
223                 for n in v:gmatch("([^;, ]+)[;, ]?") do
224                         if unique[n] == nil then
225                                 i = i + 1
226                                 kernels[i] = n
227                                 unique[n] = true
228                         end
229                 end
230         end
231
232         -- Do not attempt to autodetect if underlying filesystem
233         -- do not support directory listing (e.g. tftp, http)
234         if not lfs.attributes("/boot", "mode") then
235                 autodetect = "no"
236                 loader.setenv("kernels_autodetect", "NO")
237         end
238
239         -- Base whether we autodetect kernels or not on a loader.conf(5)
240         -- setting, kernels_autodetect. If it's set to 'yes', we'll add
241         -- any kernels we detect based on the criteria described.
242         if autodetect:lower() ~= "yes" then
243                 core.cached_kernels = kernels
244                 return core.cached_kernels
245         end
246
247         -- Automatically detect other bootable kernel directories using a
248         -- heuristic.  Any directory in /boot that contains an ordinary file
249         -- named "kernel" is considered eligible.
250         for file, ftype in lfs.dir("/boot") do
251                 local fname = "/boot/" .. file
252
253                 if file == "." or file == ".." then
254                         goto continue
255                 end
256
257                 if ftype then
258                         if ftype ~= lfs.DT_DIR then
259                                 goto continue
260                         end
261                 elseif lfs.attributes(fname, "mode") ~= "directory" then
262                         goto continue
263                 end
264
265                 if lfs.attributes(fname .. "/kernel", "mode") ~= "file" then
266                         goto continue
267                 end
268
269                 if unique[file] == nil then
270                         i = i + 1
271                         kernels[i] = file
272                         unique[file] = true
273                 end
274
275                 ::continue::
276         end
277         core.cached_kernels = kernels
278         return core.cached_kernels
279 end
280
281 function core.bootenvDefault()
282         return loader.getenv("zfs_be_active")
283 end
284
285 function core.bootenvList()
286         local bootenv_count = tonumber(loader.getenv(bootenv_list .. "_count"))
287         local bootenvs = {}
288         local curenv
289         local envcount = 0
290         local unique = {}
291
292         if bootenv_count == nil or bootenv_count <= 0 then
293                 return bootenvs
294         end
295
296         -- Currently selected bootenv is always first/default
297         -- On the rewinded list the bootenv may not exists
298         if core.isRewinded() then
299                 curenv = core.bootenvDefaultRewinded()
300         else
301                 curenv = core.bootenvDefault()
302         end
303         if curenv ~= nil then
304                 envcount = envcount + 1
305                 bootenvs[envcount] = curenv
306                 unique[curenv] = true
307         end
308
309         for curenv_idx = 0, bootenv_count - 1 do
310                 curenv = loader.getenv(bootenv_list .. "[" .. curenv_idx .. "]")
311                 if curenv ~= nil and unique[curenv] == nil then
312                         envcount = envcount + 1
313                         bootenvs[envcount] = curenv
314                         unique[curenv] = true
315                 end
316         end
317         return bootenvs
318 end
319
320 function core.isCheckpointed()
321         return loader.getenv("zpool_checkpoint") ~= nil
322 end
323
324 function core.bootenvDefaultRewinded()
325         local defname =  "zfs:!" .. string.sub(core.bootenvDefault(), 5)
326         local bootenv_count = tonumber("bootenvs_check_count")
327
328         if bootenv_count == nil or bootenv_count <= 0 then
329                 return defname
330         end
331
332         for curenv_idx = 0, bootenv_count - 1 do
333                 local curenv = loader.getenv("bootenvs_check[" .. curenv_idx .. "]")
334                 if curenv == defname then
335                         return defname
336                 end
337         end
338
339         return loader.getenv("bootenvs_check[0]")
340 end
341
342 function core.isRewinded()
343         return bootenv_list == "bootenvs_check"
344 end
345
346 function core.changeRewindCheckpoint()
347         if core.isRewinded() then
348                 bootenv_list = "bootenvs"
349         else
350                 bootenv_list = "bootenvs_check"
351         end
352 end
353
354 function core.loadEntropy()
355         if core.isUEFIBoot() then
356                 if (loader.getenv("entropy_efi_seed") or "no"):lower() == "yes" then
357                         loader.perform("efi-seed-entropy")
358                 end
359         end
360 end
361
362 function core.setDefaults()
363         core.setACPI(core.getACPIPresent(true))
364         core.setSafeMode(default_safe_mode)
365         core.setSingleUser(default_single_user)
366         core.setVerbose(default_verbose)
367 end
368
369 function core.autoboot(argstr)
370         -- loadelf() only if we've not already loaded a kernel
371         if loader.getenv("kernelname") == nil then
372                 config.loadelf()
373         end
374         core.loadEntropy()
375         loader.perform(composeLoaderCmd("autoboot", argstr))
376 end
377
378 function core.boot(argstr)
379         -- loadelf() only if we've not already loaded a kernel
380         if loader.getenv("kernelname") == nil then
381                 config.loadelf()
382         end
383         core.loadEntropy()
384         loader.perform(composeLoaderCmd("boot", argstr))
385 end
386
387 function core.isSingleUserBoot()
388         local single_user = loader.getenv("boot_single")
389         return single_user ~= nil and single_user:lower() == "yes"
390 end
391
392 function core.isUEFIBoot()
393         local efiver = loader.getenv("efi-version")
394
395         return efiver ~= nil
396 end
397
398 function core.isZFSBoot()
399         local c = loader.getenv("currdev")
400
401         if c ~= nil then
402                 return c:match("^zfs:") ~= nil
403         end
404         return false
405 end
406
407 function core.isFramebufferConsole()
408         local c = loader.getenv("console")
409         if c ~= nil then
410                 if c:find("efi") == nil and c:find("vidconsole") == nil then
411                         return false
412                 end
413                 if loader.getenv("screen.depth") ~= nil then
414                         return true
415                 end
416         end
417         return false
418 end
419
420 function core.isSerialConsole()
421         local c = loader.getenv("console")
422         if c ~= nil then
423                 -- serial console is comconsole, but also userboot.
424                 -- userboot is there, because we have no way to know
425                 -- if the user terminal can draw unicode box chars or not.
426                 if c:find("comconsole") ~= nil or c:find("userboot") ~= nil then
427                         return true
428                 end
429         end
430         return false
431 end
432
433 function core.isSerialBoot()
434         local s = loader.getenv("boot_serial")
435         if s ~= nil then
436                 return true
437         end
438
439         local m = loader.getenv("boot_multicons")
440         if m ~= nil then
441                 return true
442         end
443         return false
444 end
445
446 function core.isSystem386()
447         return loader.machine_arch == "i386"
448 end
449
450 -- Is the menu skipped in the environment in which we've booted?
451 function core.isMenuSkipped()
452         return string.lower(loader.getenv("beastie_disable") or "") == "yes"
453 end
454
455 -- This may be a better candidate for a 'utility' module.
456 function core.deepCopyTable(tbl)
457         local new_tbl = {}
458         for k, v in pairs(tbl) do
459                 if type(v) == "table" then
460                         new_tbl[k] = core.deepCopyTable(v)
461                 else
462                         new_tbl[k] = v
463                 end
464         end
465         return new_tbl
466 end
467
468 -- XXX This should go away if we get the table lib into shape for importing.
469 -- As of now, it requires some 'os' functions, so we'll implement this in lua
470 -- for our uses
471 function core.popFrontTable(tbl)
472         -- Shouldn't reasonably happen
473         if #tbl == 0 then
474                 return nil, nil
475         elseif #tbl == 1 then
476                 return tbl[1], {}
477         end
478
479         local first_value = tbl[1]
480         local new_tbl = {}
481         -- This is not a cheap operation
482         for k, v in ipairs(tbl) do
483                 if k > 1 then
484                         new_tbl[k - 1] = v
485                 end
486         end
487
488         return first_value, new_tbl
489 end
490
491 function core.getConsoleName()
492         if loader.getenv("boot_multicons") ~= nil then
493                 if loader.getenv("boot_serial") ~= nil then
494                         return "Dual (Serial primary)"
495                 else
496                         return "Dual (Video primary)"
497                 end
498         else
499                 if loader.getenv("boot_serial") ~= nil then
500                         return "Serial"
501                 else
502                         return "Video"
503                 end
504         end
505 end
506
507 function core.nextConsoleChoice()
508         if loader.getenv("boot_multicons") ~= nil then
509                 if loader.getenv("boot_serial") ~= nil then
510                         loader.unsetenv("boot_serial")
511                 else
512                         loader.unsetenv("boot_multicons")
513                         loader.setenv("boot_serial", "YES")
514                 end
515         else
516                 if loader.getenv("boot_serial") ~= nil then
517                         loader.unsetenv("boot_serial")
518                 else
519                         loader.setenv("boot_multicons", "YES")
520                         loader.setenv("boot_serial", "YES")
521                 end
522         end
523 end
524
525 recordDefaults()
526 hook.register("config.reloaded", core.clearCachedKernels)
527 return core