451 lines
12 KiB
Lua
451 lines
12 KiB
Lua
--:Minify:--
|
|
local EFI=...
|
|
--pf
|
|
EFI.beep(440, 500)
|
|
local screen=EFI.screenCtl
|
|
local ifs=EFI.initfs
|
|
local disks=EFI.disks
|
|
local arch=EFI.architecture
|
|
local kernel = {}
|
|
kernel.LOG_Text=""
|
|
kernel.version="HyperionOS V1.2.4"
|
|
kernel.tag="1.2.4"
|
|
kernel.process = "Kernel"
|
|
kernel.users={[0]="root",[1000]="User"}
|
|
kernel.hostname = "hyperion"
|
|
kernel.groups = {}
|
|
kernel.uid = 0
|
|
kernel.gid = 0
|
|
kernel.status = "start"
|
|
kernel.key = {}
|
|
kernel.cache = {}
|
|
kernel.cache.preload = {}
|
|
kernel.unixSockets={}
|
|
kernel._G=_G
|
|
kernel.sleep=sleep
|
|
|
|
_G.sleep=nil
|
|
local windowsExp = false
|
|
|
|
function kernel.log(msg, level, c, nopanic)
|
|
local f=function()
|
|
c=c or 0x6D6D6D
|
|
kernel.LOG_Text = kernel.LOG_Text..tostring(EFI:date()).." "..kernel.users[kernel.uid].." "..kernel.process.."["..tostring(level or "INFO").."]: "..msg.."\n"
|
|
if kernel.status == "start" then
|
|
screen:setTextColor(c)
|
|
screen:print(tostring(EFI:date()).." "..kernel.users[kernel.uid].." "..kernel.process.."["..tostring(level or "INFO").."]: "..msg)
|
|
elseif kernel.status == "term" then
|
|
kernel.standbyTask=kernel.currentTask
|
|
kernel.currentTask=kernel.kernelTask
|
|
local file=kernel.vfs.open("/dev/console", "w")
|
|
kernel.vfs.devctl(file,"sfgc",c)
|
|
kernel.vfs.write(file,tostring(EFI:date()).." "..kernel.users[kernel.uid].." "..kernel.process.."["..tostring(level or "INFO").."]: "..msg.."\n")
|
|
kernel.vfs.close(file)
|
|
kernel.currentTask=kernel.standbyTask
|
|
end
|
|
end
|
|
|
|
local ok,err = xpcall(f,debug.traceback)
|
|
if not ok and not nopanic then
|
|
kernel.panic(err)
|
|
end
|
|
end
|
|
|
|
function kernel.PANIC(msg)
|
|
if kernel.status~="Panic" then
|
|
kernel.log("PANIC: "..msg, "PANIC", 0xFF0000)
|
|
pcall(kernel["saveLog"])
|
|
kernel.status="Panic"
|
|
kernel.reason=msg
|
|
screen:enable()
|
|
screen:setTextColor(0xFF0000)
|
|
screen:setBackgroundColor(0x000000)
|
|
screen:clear()
|
|
screen:resetCursor()
|
|
screen:print(kernel.LOG_Text)
|
|
screen:print("KERNEL PANIC!\n"..msg.."\nSystem halted.")
|
|
screen:print("Press any key to continue...")
|
|
kernel.exitMain = true
|
|
end
|
|
while true do
|
|
local event={EFI:getMachineEvent()}
|
|
if event[1]=="keyPressed" then
|
|
break
|
|
end
|
|
end
|
|
EFI.reboot=true
|
|
error("KERNEL PANIC")
|
|
end
|
|
kernel.panic=kernel.PANIC
|
|
|
|
if windowsExp then
|
|
screen:setTextColor(0xFFFFFF)
|
|
screen:setBackgroundColor(0x0000FF)
|
|
screen:clear()
|
|
screen:resetCursor()
|
|
screen:print("\n\n\n\n\n :(")
|
|
screen:print("\n Your PC ran into a problem and needs to restart. We're just collecting some error")
|
|
screen:print(" info, and then we'll restart for you.\n")
|
|
screen:print("\n\n\n Stop code: average windows experience")
|
|
while true do end
|
|
end
|
|
|
|
kernel.log("Kernel loaded.")
|
|
kernel.log("Mounting init disks...")
|
|
disks.refresh()
|
|
ifs.update(disks)
|
|
kernel.disks={}
|
|
for _,v in disks.list() do
|
|
kernel.disks[v.address] = v
|
|
end
|
|
ifs.mount("$", "/")
|
|
|
|
local fstab=ifs.readAllText("/boot/fstab")
|
|
local split = function(str, delim, maxResultCountOrNil)
|
|
assert(#delim == 1, "only delim len 1 supported for now")
|
|
maxResultCountOrNil = (maxResultCountOrNil or 0)-1
|
|
local rv = {}
|
|
local buf = ""
|
|
for i = 1, #str do
|
|
local c = string.sub(str,i,i)
|
|
if #rv ~= maxResultCountOrNil and c == delim then
|
|
table.insert(rv, buf)
|
|
buf = ""
|
|
else
|
|
buf = buf..c
|
|
end
|
|
end
|
|
table.insert(rv, buf)
|
|
return rv
|
|
end
|
|
|
|
if not ifs.isFile("/boot/boot.cfg") then
|
|
kernel.log("First boot detected writing boot.cfg", "INFO", 0x00FF00)
|
|
ifs.writeAllText("/boot/boot.cfg",ifs.readAllText("/boot/safeboot.cfg"))
|
|
kernel.firstBoot=true
|
|
end
|
|
|
|
local initCfgFunc, err = load(ifs.readAllText("/boot/boot.cfg"), "@boot.cfg")
|
|
if not initCfgFunc then
|
|
kernel.PANIC("Failed to load /boot/boot.cfg: "..tostring(err))
|
|
end
|
|
|
|
---@diagnostic disable-next-line: param-type-mismatch
|
|
local initCfgStatus, config = pcall(initCfgFunc)
|
|
if not initCfgStatus then
|
|
kernel.PANIC("Error in /boot/boot.cfg: "..tostring(config))
|
|
end
|
|
kernel.config = config
|
|
|
|
local skip=false
|
|
for i,v in ipairs(split(fstab,"\n")) do
|
|
if v:sub(1,1)=="U" then
|
|
local id=""
|
|
for i=3,#v do
|
|
if v:sub(i,i)==";" then
|
|
if i==3 then kernel.log("Invalid fstab line... Skipping.","WARN", 0xFF8800) skip = true break end
|
|
id=v:sub(3,i-1)
|
|
end
|
|
end
|
|
if not skip then
|
|
local path=v:sub(#id+4)
|
|
ifs.mount(id,path)
|
|
else
|
|
skip=false
|
|
end
|
|
end
|
|
end
|
|
kernel.log("Disks initialized")
|
|
|
|
function kernel.saveLog()
|
|
if kernel.status=="running" then
|
|
local file = kernel.vfs.open("/var/log/syslog.log", "w")
|
|
kernel.vfs.write(file, kernel.LOG_Text)
|
|
kernel.vfs.close(file)
|
|
else
|
|
ifs.writeAllText("/var/log/syslog.log", kernel.LOG_Text)
|
|
end
|
|
end
|
|
|
|
function kernel.newFifo()
|
|
local fifo = {}
|
|
fifo.push=function(data)
|
|
table.insert(fifo, data)
|
|
end
|
|
fifo.pop=function()
|
|
return table.remove(fifo,1)
|
|
end
|
|
return fifo
|
|
end
|
|
|
|
function kernel.newUUID()
|
|
local template = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx"
|
|
local uuid = ""
|
|
for i = 1, #template do
|
|
local c = template:sub(i,i)
|
|
if c == "x" then
|
|
uuid = uuid .. string.format("%x", math.random(0, 15))
|
|
elseif c == "y" then
|
|
uuid = uuid .. string.format("%x", math.random(8, 11))
|
|
else
|
|
uuid = uuid .. c
|
|
end
|
|
end
|
|
return uuid
|
|
end
|
|
|
|
function kernel.sfile(str, writeable)
|
|
local buf = {str or ""}
|
|
local pos = 1
|
|
local closed = false
|
|
|
|
local function content()
|
|
return table.concat(buf)
|
|
end
|
|
|
|
local function set_content(s)
|
|
buf = {s}
|
|
end
|
|
|
|
local function flush()
|
|
str=content()
|
|
end
|
|
|
|
local file = {}
|
|
|
|
function file.read(n)
|
|
assert(not closed, "file is closed")
|
|
|
|
local s = content()
|
|
local len = #s
|
|
|
|
if not n then
|
|
local out = s:sub(pos)
|
|
pos = len + 1
|
|
return out
|
|
end
|
|
|
|
local out = s:sub(pos, pos + n - 1)
|
|
pos = pos + #out
|
|
return out
|
|
end
|
|
|
|
if writeable then
|
|
function file.write(data)
|
|
assert(not closed, "file is closed")
|
|
|
|
local s = content()
|
|
local before = s:sub(1, pos - 1)
|
|
local after = s:sub(pos + #data)
|
|
|
|
set_content(before .. data .. after)
|
|
pos = pos + #data
|
|
|
|
return true
|
|
end
|
|
end
|
|
|
|
function file.seek(whence, offset)
|
|
assert(not closed, "file is closed")
|
|
|
|
local s = content()
|
|
local len = #s
|
|
|
|
whence = whence or "cur"
|
|
offset = offset or 0
|
|
|
|
if whence == "set" then
|
|
pos = offset + 1
|
|
elseif whence == "cur" then
|
|
pos = pos + offset
|
|
elseif whence == "end" then
|
|
pos = len + offset + 1
|
|
else
|
|
error("invalid whence")
|
|
end
|
|
|
|
if pos < 1 then pos = 1 end
|
|
if pos > len + 1 then pos = len + 1 end
|
|
|
|
return pos - 1
|
|
end
|
|
|
|
function file.close()
|
|
assert(not closed, "file is closed")
|
|
flush()
|
|
closed = true
|
|
end
|
|
|
|
function file.flush()
|
|
assert(not closed, "file is closed")
|
|
flush()
|
|
end
|
|
|
|
function file.content()
|
|
return str
|
|
end
|
|
|
|
return file
|
|
end
|
|
|
|
kernel.syscalls={}
|
|
local modules={[0]={}}
|
|
for i=0, 100 do
|
|
modules[i]={}
|
|
end
|
|
|
|
kernel.log("Gathering modules")
|
|
for _, i in ipairs(ifs.list("/lib/modules")) do
|
|
local modlist = ifs.list("/lib/modules/"..i)
|
|
if not modlist then
|
|
kernel.log("WARNING: could not list /lib/modules/"..i.." (skipping)", "WARN", 0xFF8800)
|
|
else
|
|
for _,v in ipairs(modlist) do
|
|
local prior=tonumber(v:sub(1,2))
|
|
if prior then
|
|
modules[prior+1][#modules[prior+1]+1]=i.."/"..v
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
kernel.ifs=ifs
|
|
--pf
|
|
kernel.apis=EFI.firmware
|
|
--pf
|
|
kernel.EFI=EFI
|
|
kernel.arch=arch
|
|
kernel.initdisks=disks
|
|
kernel.screen=screen
|
|
kernel.processes={}
|
|
kernel.fstab=fstab
|
|
kernel.denied={}
|
|
kernel.loadingModule="kernel"
|
|
|
|
kernel.kernelTask = {
|
|
name="kernel",
|
|
status="R",
|
|
pid=0,
|
|
tgid=0,
|
|
uid=0,
|
|
fd={},
|
|
exit="",
|
|
sleep=0,
|
|
ivs=0,
|
|
vs=0,
|
|
children={},
|
|
syscallReturn={},
|
|
cwd="/",
|
|
timeSlice=0,
|
|
lastTime=0,
|
|
totalTime=0,
|
|
numRuns=0
|
|
}
|
|
kernel.currentTask = kernel.kernelTask
|
|
|
|
function kernel.shutdown()
|
|
kernel.exitMain=true
|
|
kernel.status="shutdown"
|
|
end
|
|
|
|
function kernel.reboot()
|
|
kernel.exitMain=true
|
|
kernel.status="reboot"
|
|
end
|
|
|
|
function kernel.halt()
|
|
kernel.exitMain=true
|
|
kernel.status="halt"
|
|
end
|
|
|
|
function kernel.asyncReturn(...)
|
|
kernel.currentTask.syscallReturn = {...}
|
|
end
|
|
|
|
function kernel.deny(moduleid)
|
|
kernel.denied[moduleid]=true
|
|
if kernel.config.showModLoad then kernel.log("Module "..kernel.loadingModule.." denied "..moduleid, "DBUG", 0xFF0000) end
|
|
end
|
|
|
|
kernel.syscalls["time"]=function() return kernel.EFI:getEpochMs() end
|
|
kernel.syscalls["date"]=function() return kernel.EFI:date() end
|
|
kernel.syscalls["log"]=kernel.log
|
|
kernel.syscalls["tag"]=function() return kernel.tag end
|
|
kernel.syscalls["getUptime"]=function() return kernel.EFI:getUptime() end
|
|
kernel.syscalls["getUsername"]=function(uid) return kernel.users[uid or kernel.uid] end
|
|
kernel.syscalls["getHostname"]=function() return kernel.hostname end
|
|
kernel.syscalls["getHost"]=function() return kernel.apis._HOST end
|
|
kernel.syscalls["version"]=function() return kernel.version end
|
|
kernel.syscalls["setHostname"]=function(name) if kernel.uid~=0 then error("Permission denied") end kernel.hostname=name end
|
|
kernel.syscalls["arch"]=function() return arch end
|
|
kernel.syscalls["sysdump"]=function()
|
|
local rv={}
|
|
for i,v in pairs(kernel.syscalls) do
|
|
rv[#rv+1] = i
|
|
end
|
|
return rv
|
|
end
|
|
kernel.syscalls["reboot"]=function()
|
|
if kernel.uid==0 or kernel.groups.wheel then
|
|
kernel.reboot()
|
|
end
|
|
end
|
|
kernel.syscalls["shutdown"]=function()
|
|
if kernel.uid==0 or kernel.groups.wheel then
|
|
kernel.shutdown()
|
|
end
|
|
end
|
|
kernel.syscalls["halt"]=function()
|
|
if kernel.uid==0 or kernel.groups.wheel then
|
|
kernel.halt()
|
|
end
|
|
end
|
|
kernel.syscalls["saveLog"]=function()
|
|
if kernel.uid==0 or kernel.groups.wheel then
|
|
kernel.saveLog()
|
|
end
|
|
end
|
|
|
|
kernel.saveLog()
|
|
kernel.log("Running modules")
|
|
for _,p in ipairs(modules) do
|
|
for _,v in ipairs(p) do
|
|
kernel.loadingModule=v
|
|
if not kernel.denied[v] then
|
|
if kernel.config.showModLoad then kernel.log("Loading module "..v, "DBUG", 0x00FFFF) end
|
|
local code=ifs.readAllText("/lib/modules/"..v)
|
|
if not code then
|
|
kernel.panic("Failed to read module "..v)
|
|
end
|
|
local func,err=load(code,"@"..v)
|
|
if not func then kernel.panic("ModuLoadErr: "..tostring(err)) end
|
|
local status, err = xpcall(func,debug.traceback, kernel)
|
|
if not status then kernel.panic("ModuRunErr: "..tostring(err)) end
|
|
if kernel.config.showModLoad then kernel.log("Loaded module "..v, "DBUG", 0x00FFFF) end
|
|
if kernel.config.moreLogsaves then kernel.saveLog() end
|
|
else
|
|
if kernel.config.showModLoad then kernel.log("Denied module "..v, "DBUG", 0xFF0000) end
|
|
end
|
|
end
|
|
end
|
|
|
|
kernel.log("Kernel initialized successfully.")
|
|
kernel.saveLog()
|
|
kernel.status="running"
|
|
kernel.loadingModule=nil
|
|
screen:disable()
|
|
local ok,err = xpcall(kernel.main, debug.traceback)
|
|
if not ok then
|
|
kernel.panic(err)
|
|
end
|
|
if kernel.status=="panic" then
|
|
kernel.panic(kernel.reason)
|
|
end
|
|
if kernel.status=="reboot" then
|
|
EFI.reboot=true
|
|
return true
|
|
elseif kernel.status=="halt" then
|
|
kernel.log("System halted.")
|
|
kernel.saveLog()
|
|
while true do end
|
|
end |