formating better for spm packages
This commit is contained in:
@@ -0,0 +1,4 @@
|
||||
U $;/
|
||||
U devfs0000;/dev/
|
||||
U tmpfs0000;/tmp/
|
||||
U procfs0000;/proc/
|
||||
@@ -0,0 +1,84 @@
|
||||
-- :Minify:--
|
||||
local fs = {}
|
||||
local disks = {}
|
||||
local mounts = {}
|
||||
|
||||
local function resolve(path)
|
||||
local mountPoint = "/"
|
||||
for mount, disk in pairs(mounts) do
|
||||
if path:sub(1, #mount) == mount then
|
||||
if not mountPoint or #mount > #mountPoint then
|
||||
mountPoint = mount
|
||||
end
|
||||
end
|
||||
end
|
||||
local newPath = path:sub(#mountPoint + 1)
|
||||
return disks[mounts[mountPoint]], newPath
|
||||
end
|
||||
|
||||
function fs.update(initdisks)
|
||||
disks = {}
|
||||
for k, v in initdisks.list() do disks[k] = v end
|
||||
end
|
||||
|
||||
function fs.exists(path)
|
||||
local disk, newPath = resolve(path)
|
||||
return disk:directoryExists(newPath) or disk:fileExists(newPath)
|
||||
end
|
||||
|
||||
function fs.isFile(path)
|
||||
local disk, newPath = resolve(path)
|
||||
return disk:fileExists(newPath)
|
||||
end
|
||||
|
||||
function fs.isDir(path)
|
||||
local disk, newPath = resolve(path)
|
||||
return disk:directoryExists(newPath)
|
||||
end
|
||||
|
||||
function fs.list(path)
|
||||
local disk, newPath = resolve(path)
|
||||
return disk:list(newPath)
|
||||
end
|
||||
|
||||
function fs.makeDir(path)
|
||||
local disk, newPath = resolve(path)
|
||||
return disk:makeDirectory(newPath)
|
||||
end
|
||||
|
||||
function fs.remove(path)
|
||||
local disk, newPath = resolve(path)
|
||||
return disk:remove(newPath)
|
||||
end
|
||||
|
||||
function fs.readAllText(path)
|
||||
local disk, newPath = resolve(path)
|
||||
local handle = disk:open(newPath, "r")
|
||||
if not handle then return nil end
|
||||
local content = handle.readAll()
|
||||
handle.close()
|
||||
return content
|
||||
end
|
||||
|
||||
function fs.writeAllText(path, text)
|
||||
local disk, newPath = resolve(path)
|
||||
local handle = disk:open(newPath, "w")
|
||||
handle.write(text)
|
||||
handle.close()
|
||||
end
|
||||
|
||||
function fs.appendAllText(path, text)
|
||||
local disk, newPath = resolve(path)
|
||||
local handle = disk:open(newPath, "a")
|
||||
handle.write(text)
|
||||
handle.close()
|
||||
end
|
||||
|
||||
function fs.load(path) return load(fs.readAllText(path), path) end
|
||||
|
||||
function fs.mount(disk, mountPoint)
|
||||
if not disks[disk] then return end
|
||||
mounts[mountPoint] = disk
|
||||
end
|
||||
|
||||
return fs
|
||||
@@ -0,0 +1,297 @@
|
||||
--:Minify:--
|
||||
local EFI=...
|
||||
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-dev_5"
|
||||
kernel.tag="1.2.4-dev_5"
|
||||
kernel.process = "Kernel"
|
||||
kernel.users={[0]="root",[1]="User"}
|
||||
kernel.hostname = "hyperion"
|
||||
kernel.groups = {}
|
||||
kernel.uid = 0
|
||||
kernel.gid = 0
|
||||
kernel.status = "start"
|
||||
kernel.key = {}
|
||||
kernel.cache = {}
|
||||
kernel.cache.preload = {}
|
||||
kernel._G=_G
|
||||
kernel.sleep=sleep
|
||||
|
||||
_G.sleep=nil
|
||||
local windowsExp = true
|
||||
|
||||
function kernel.log(msg, level, c)
|
||||
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
|
||||
|
||||
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
|
||||
|
||||
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]="/lib/modules/"..i.."/"..v
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
kernel.ifs=ifs
|
||||
kernel.apis=EFI.firmware
|
||||
kernel.EFI=EFI
|
||||
kernel.arch=arch
|
||||
kernel.initdisks=disks
|
||||
kernel.screen=screen
|
||||
kernel.processes={}
|
||||
kernel.fstab=fstab
|
||||
|
||||
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
|
||||
|
||||
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"]=kernel.reboot
|
||||
kernel.syscalls["shutdown"]=kernel.shutdown
|
||||
|
||||
kernel.log("Running modules")
|
||||
for _,p in ipairs(modules) do
|
||||
for _,v in ipairs(p) do
|
||||
if kernel.config.showModLoad then kernel.log("Loading module "..v, "DBUG", 0x00FFFF) end
|
||||
local code=ifs.readAllText(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
|
||||
end
|
||||
end
|
||||
|
||||
kernel.log("Kernel initialized successfully.")
|
||||
kernel.saveLog()
|
||||
kernel.status="running"
|
||||
screen:disable()
|
||||
kernel.main()
|
||||
if kernel.status=="panic" then
|
||||
kernel.panic(kernel.reason)
|
||||
end
|
||||
if kernel.status=="reboot" then
|
||||
EFI.reboot=true
|
||||
return true
|
||||
end
|
||||
@@ -0,0 +1,11 @@
|
||||
-- DO NOT EDIT THIS FILE IF YOU DO NOT KNOW WHAT YOU ARE DOING!
|
||||
-- DOING SO MAY RENDER YOUR SYSTEM UNBOOTABLE!
|
||||
|
||||
-- This file is auto-generated during the build process.
|
||||
-- DEFAULT BOOT CONFIGURATION FILE
|
||||
return {
|
||||
initPath = "/sbin/init",
|
||||
maxOpenFiles = 128,
|
||||
maxFilesPerTask = 16,
|
||||
preempt=true
|
||||
}
|
||||
@@ -0,0 +1 @@
|
||||
0:0:root:/root:/bin/hysh
|
||||
@@ -0,0 +1,258 @@
|
||||
--:Minify:--
|
||||
--- @diagnostic disable: duplicate-set-field
|
||||
local kernel = ...
|
||||
kernel.allowGlobalOverwrites = true
|
||||
|
||||
function string.hasSuffix(str, suffix)
|
||||
return string.sub(str, #suffix + 1) == suffix
|
||||
end
|
||||
|
||||
function string.hasPrefix(str, prefix)
|
||||
return string.sub(str, 1, #prefix) == prefix
|
||||
end
|
||||
|
||||
function string.getSuffix(str, prefix) return string.sub(str, #prefix + 1) end
|
||||
|
||||
function string.getPrefix(str, suffix) return string.sub(str, 1, #suffix) end
|
||||
|
||||
function string.join(str, ...) return table.concat(table.pack(str, ...)) end
|
||||
|
||||
function string.delim(str, ...) return table.concat(table.pack(...), str) end
|
||||
|
||||
function string.split(str, delim, maxResultCountOrNil)
|
||||
assert(#delim == 1, "only delim len 1 supported for now")
|
||||
if not str then return false end
|
||||
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
|
||||
|
||||
function table.deepcopy(orig, copies)
|
||||
copies = copies or {}
|
||||
|
||||
if type(orig) ~= 'table' then
|
||||
return orig
|
||||
elseif copies[orig] then
|
||||
return copies[orig]
|
||||
end
|
||||
|
||||
local copy = {}
|
||||
copies[orig] = copy
|
||||
|
||||
for k, v in next, orig, nil do
|
||||
local copied_key = table.deepcopy(k, copies)
|
||||
local copied_val = table.deepcopy(v, copies)
|
||||
copy[copied_key] = copied_val
|
||||
end
|
||||
|
||||
return copy
|
||||
end
|
||||
|
||||
function table.hasKey(tabl, query)
|
||||
for i, v in pairs(tabl) do if i == query then return v end end
|
||||
return false
|
||||
end
|
||||
|
||||
function table.hasVal(tabl, query)
|
||||
for i, v in pairs(tabl) do if v == query then return i end end
|
||||
return false
|
||||
end
|
||||
|
||||
local function serialize(tbl, seen)
|
||||
seen = seen or {}
|
||||
|
||||
if seen[tbl] then return '"[Circular Reference]"' end
|
||||
|
||||
seen[tbl] = true
|
||||
|
||||
local output = "{"
|
||||
local first = true
|
||||
|
||||
for i, v in pairs(tbl) do
|
||||
if not first then output = output .. "," end
|
||||
first = false
|
||||
|
||||
if type(i) == "string" then
|
||||
output = output .. "[\"" .. i .. "\"]="
|
||||
elseif type(i) == "number" then
|
||||
output = output .. "[" .. tostring(i) .. "]="
|
||||
end
|
||||
|
||||
if type(v) == "table" then
|
||||
output = output .. serialize(v, seen)
|
||||
elseif type(v) == "string" then
|
||||
output = output .. "[=[" .. v .. "]=]"
|
||||
elseif type(v) == "number" or type(v) == "boolean" then
|
||||
output = output .. tostring(v)
|
||||
elseif type(v) == "function" then
|
||||
output = output .. "\"" .. tostring(v) .. "\""
|
||||
elseif type(v) == "thread" then
|
||||
output = output .. "\"" .. tostring(v) .. "\""
|
||||
else
|
||||
error("serialization of type \"" .. type(v) .. "\" is not supported")
|
||||
end
|
||||
end
|
||||
|
||||
seen[tbl] = nil
|
||||
|
||||
output = output .. "}"
|
||||
return output
|
||||
end
|
||||
|
||||
local oldtype = type
|
||||
local oldgetmetatable = getmetatable
|
||||
function type(object, trueType)
|
||||
if trueType then return oldtype(object) end
|
||||
if oldtype(object) ~= "table" then
|
||||
return oldtype(object)
|
||||
else
|
||||
if oldtype(oldgetmetatable(object)) == "table" then
|
||||
local metatable = oldgetmetatable(object)
|
||||
---@diagnostic disable-next-line: need-check-nil
|
||||
if metatable.__type then return metatable.__type end
|
||||
else
|
||||
return "table"
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
function getmetatable(object)
|
||||
if oldtype(object) ~= "table" then return end
|
||||
if oldtype(oldgetmetatable(object)) == "table" then
|
||||
if oldgetmetatable(object).__isuserdata then
|
||||
if oldtype(oldgetmetatable(object).__usermeta) == "function" then
|
||||
return oldgetmetatable(object).__usermeta()
|
||||
else
|
||||
return oldgetmetatable(object).__usermeta
|
||||
end
|
||||
else
|
||||
return oldgetmetatable(object)
|
||||
end
|
||||
else
|
||||
return oldgetmetatable(object)
|
||||
end
|
||||
end
|
||||
|
||||
function isEqualToAny(a, ...)
|
||||
local args = {...}
|
||||
for i = 0, #args do if a == args[i] then return true end end
|
||||
return false
|
||||
end
|
||||
|
||||
function isEqualToAll(a, ...)
|
||||
local args = {...}
|
||||
for i = 0, #args do if a ~= args[i] then return false end end
|
||||
return true
|
||||
end
|
||||
|
||||
function table.keys(t)
|
||||
local a = {}
|
||||
for n in pairs(t) do table.insert(a, n) end
|
||||
return a
|
||||
end
|
||||
|
||||
function table.values(t)
|
||||
local a = {}
|
||||
for _, n in pairs(t) do table.insert(a, n) end
|
||||
return a
|
||||
end
|
||||
|
||||
function table.indexOf(t, value)
|
||||
for i, v in ipairs(t) do if v == value then return i end end
|
||||
return -1
|
||||
end
|
||||
|
||||
function table.merge(...)
|
||||
local args={...}
|
||||
local out = {}
|
||||
local outi = {}
|
||||
|
||||
for _,t in ipairs(args) do
|
||||
for i,v in pairs(t) do
|
||||
out[i]=v
|
||||
end
|
||||
for i,v in ipairs(t) do
|
||||
outi[#outi+1]=v
|
||||
end
|
||||
end
|
||||
|
||||
for i,v in ipairs(outi) do
|
||||
out[i]=v
|
||||
end
|
||||
|
||||
return out
|
||||
end
|
||||
|
||||
function string.replace(s, target, repl)
|
||||
local result = {}
|
||||
local i = 1
|
||||
local n = #s
|
||||
local t_len = #target
|
||||
|
||||
while i <= n do
|
||||
local match = true
|
||||
if i + t_len - 1 <= n then
|
||||
for j = 1, t_len do
|
||||
if s:sub(i + j - 1, i + j - 1) ~= target:sub(j, j) then
|
||||
match = false
|
||||
break
|
||||
end
|
||||
end
|
||||
else
|
||||
match = false
|
||||
end
|
||||
|
||||
if match then
|
||||
table.insert(result, repl)
|
||||
i = i + t_len
|
||||
else
|
||||
table.insert(result, s:sub(i, i))
|
||||
i = i + 1
|
||||
end
|
||||
end
|
||||
|
||||
return table.concat(result)
|
||||
end
|
||||
|
||||
function toHex(num)
|
||||
return string.format("%X", num)
|
||||
end
|
||||
|
||||
local function makeSyscallProxy()
|
||||
local backing = {}
|
||||
return setmetatable(backing, {
|
||||
__index = function(self, name)
|
||||
local raw = rawget(self, name)
|
||||
if raw ~= nil then return raw end
|
||||
return function(...)
|
||||
local res = table.pack(coroutine.yield("syscall", name, ...))
|
||||
if res[1] then
|
||||
return table.unpack(res, 2, res.n)
|
||||
else
|
||||
error(res[2], 2)
|
||||
end
|
||||
end
|
||||
end,
|
||||
__newindex = function(self, k, v)
|
||||
rawset(self, k, v)
|
||||
end,
|
||||
__metatable=false
|
||||
})
|
||||
end
|
||||
|
||||
syscall = makeSyscallProxy()
|
||||
|
||||
_makeSyscallProxy = makeSyscallProxy
|
||||
|
||||
table.serialize = serialize
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,40 @@
|
||||
--:Minify:--
|
||||
local kernel = ...
|
||||
local cache = {}
|
||||
kernel.searchpaths = {
|
||||
"/lib/?.lua", "/lib/?", "/usr/lib/?.lua", "/usr/lib/?",
|
||||
"/usr/local/lib/?.lua", "/usr/local/lib/?", "?.lua", "?"
|
||||
}
|
||||
|
||||
function require(module, ...)
|
||||
if cache[module] then return cache[module] end
|
||||
local modpath = module:gsub("%.", "/")
|
||||
local failed = {}
|
||||
for _, path in ipairs(kernel.searchpaths) do
|
||||
local full_path = string.replace(path, "?", modpath)
|
||||
if full_path:sub(1, 1) ~= "/" then
|
||||
full_path = kernel.currentTask.cwd .. full_path
|
||||
end
|
||||
|
||||
if kernel.vfs.exists(full_path) then
|
||||
if kernel.vfs.type(full_path) == "directory" then
|
||||
full_path = full_path .. "/init"
|
||||
end
|
||||
|
||||
if kernel.vfs.exists(full_path) then
|
||||
local handle = kernel.vfs.open(full_path, "r")
|
||||
local file_content = kernel.vfs.read(handle, 1024 * 1024 * 4)
|
||||
kernel.vfs.close(handle)
|
||||
|
||||
return
|
||||
assert(load(file_content, full_path, "t", kernel._U))(...)
|
||||
else
|
||||
table.insert(failed, full_path)
|
||||
end
|
||||
else
|
||||
table.insert(failed, full_path)
|
||||
end
|
||||
end
|
||||
|
||||
error("Module not found: " .. module .. " (searched paths: " .. table.concat(failed, ", ") .. ")")
|
||||
end
|
||||
@@ -0,0 +1,223 @@
|
||||
--:Minify:--
|
||||
local kernel = ...
|
||||
|
||||
local proxy = {}
|
||||
local data = {}
|
||||
|
||||
proxy.address = "devfs0000"
|
||||
proxy.isvirt = true
|
||||
proxy.isReadOnly = function() return false end
|
||||
proxy.spaceUsed = function() return 0 end
|
||||
proxy.spaceTotal = function() return 0 end
|
||||
proxy.makeDirectory = function() error("EACCES") end
|
||||
proxy.remove = function() error("EACCES") end
|
||||
proxy.setLabel = function() error("EACCES") end
|
||||
proxy.getLabel = function() return "devfs" end
|
||||
proxy.attributes = function(path) return {
|
||||
size = 0,
|
||||
modified = 0,
|
||||
created = 0
|
||||
} end
|
||||
|
||||
function proxy:open(path, mode)
|
||||
local steps = kernel.vfs.splitPath(path)
|
||||
local step = data
|
||||
for i=1, #steps-1 do
|
||||
local dat = step[steps[i]]
|
||||
if type(dat) ~= "table" then error("ENFILE") end
|
||||
step=dat
|
||||
end
|
||||
if type(step[steps[#steps]]) == "function" then
|
||||
return step[steps[#steps]]("open", mode)
|
||||
end
|
||||
error("ENFILE")
|
||||
end
|
||||
|
||||
function proxy:type(path, mode)
|
||||
local steps = kernel.vfs.splitPath(path)
|
||||
local step = data
|
||||
if #steps == 0 then
|
||||
return "directory"
|
||||
end
|
||||
for i=1, #steps-1 do
|
||||
local dat = step[steps[i]]
|
||||
if type(dat) ~= "table" then error("ENFILE") end
|
||||
step=dat
|
||||
end
|
||||
if type(step[steps[#steps]]) == "function" then
|
||||
return step[steps[#steps]]("type", mode)
|
||||
end
|
||||
if type(step[steps[#steps]]) == "table" then
|
||||
return "directory"
|
||||
end
|
||||
error("ENOENT")
|
||||
end
|
||||
|
||||
function proxy:list(path)
|
||||
local steps = kernel.vfs.splitPath(path)
|
||||
local step = data
|
||||
if #steps == 0 then
|
||||
return table.keys(data)
|
||||
end
|
||||
for i=1, #steps-1 do
|
||||
local dat = step[steps[i]]
|
||||
if type(dat) ~= "table" then error("ENOENT") end
|
||||
step=dat
|
||||
end
|
||||
if type(step[steps[#steps]]) == "table" then
|
||||
return table.keys(step[steps[#steps]])
|
||||
end
|
||||
error("ENOENT")
|
||||
end
|
||||
|
||||
function proxy:fileExists(path)
|
||||
local ok = pcall(function()
|
||||
return self:type(path)
|
||||
end)
|
||||
return ok
|
||||
end
|
||||
|
||||
function data.random(op, mode)
|
||||
if op=="type" then
|
||||
return "character device"
|
||||
elseif op=="open" then
|
||||
if mode=="r" then
|
||||
return {
|
||||
read=function(amount)
|
||||
local str = ""
|
||||
for i=1, amount or 1 do
|
||||
str=str..string.char(math.random(0, 255))
|
||||
end
|
||||
return str
|
||||
end
|
||||
}
|
||||
elseif mode=="w" or mode=="a" then
|
||||
return {
|
||||
write=function() end
|
||||
}
|
||||
else error("EACCES")
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
function data.null(op, mode)
|
||||
if op=="type" then
|
||||
return "character device"
|
||||
elseif op=="open" then
|
||||
if mode=="r" then
|
||||
return {
|
||||
read=function(amount) end
|
||||
}
|
||||
elseif mode=="w" or mode=="a" then
|
||||
return {
|
||||
write=function() end
|
||||
}
|
||||
else error("EACCES")
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
function data.zero(op, mode)
|
||||
if op=="type" then
|
||||
return "character device"
|
||||
elseif op=="open" then
|
||||
if mode=="r" then
|
||||
return {
|
||||
read=function(amount)
|
||||
local str = ""
|
||||
for i=1, amount or 1 do
|
||||
str=str..string.char(0)
|
||||
end
|
||||
return str
|
||||
end
|
||||
}
|
||||
elseif mode=="w" or mode=="a" then
|
||||
return {
|
||||
write=function() end
|
||||
}
|
||||
else error("EACCES")
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
if kernel.EFI:getEEPROM() then
|
||||
function data.eeprom(op, mode)
|
||||
if op=="type" then
|
||||
return "character device"
|
||||
elseif op=="open" then
|
||||
if mode=="r" then
|
||||
local ptr,eeprom=1,kernel.EFI:getEEPROM()
|
||||
return {
|
||||
read=function(amount)
|
||||
ptr=ptr+amount
|
||||
return eeprom:sub(ptr-amount, ptr)
|
||||
end
|
||||
}
|
||||
elseif mode=="w" then
|
||||
if kernel.uid~=0 then error("EACCES") end
|
||||
local firstwrite=true
|
||||
return {
|
||||
write=function(data)
|
||||
if firstwrite then
|
||||
kernel.EFI:setEEPROM(data)
|
||||
else
|
||||
kernel.EFI:setEEPROM(kernel.EFI:getEEPROM()..data)
|
||||
end
|
||||
end
|
||||
}
|
||||
elseif mode=="a" then
|
||||
if kernel.uid~=0 then error("EACCES") end
|
||||
return {
|
||||
write=function(data)
|
||||
kernel.EFI:setEEPROM(kernel.EFI:getEEPROM()..data)
|
||||
end
|
||||
}
|
||||
else error("EACCES")
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
if kernel.EFI:getNvram() then
|
||||
function data.nvram(op, mode)
|
||||
if op=="type" then
|
||||
return "character device"
|
||||
elseif op=="open" then
|
||||
if mode=="r" then
|
||||
local ptr,nvram=1,kernel.EFI:getNvram()
|
||||
return {
|
||||
read=function(amount)
|
||||
ptr=ptr+amount
|
||||
return nvram:sub(ptr-amount, ptr)
|
||||
end
|
||||
}
|
||||
elseif mode=="w" then
|
||||
if kernel.uid~=0 then error("EACCES") end
|
||||
local firstwrite=true
|
||||
return {
|
||||
write=function(data)
|
||||
if firstwrite then
|
||||
kernel.EFI:setNvram(data)
|
||||
else
|
||||
kernel.EFI:setNvram(kernel.EFI:getNvram()..data)
|
||||
end
|
||||
end
|
||||
}
|
||||
elseif mode=="a" then
|
||||
if kernel.uid~=0 then error("EACCES") end
|
||||
return {
|
||||
write=function(data)
|
||||
kernel.EFI:setNvram(kernel.EFI:getNvram()..data)
|
||||
end
|
||||
}
|
||||
else error("EACCES")
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
data["disk"]={}
|
||||
kernel.devfs={}
|
||||
kernel.devfs.data=data
|
||||
kernel.devfs.proxy=proxy
|
||||
kernel.disks["devfs0000"]=proxy
|
||||
@@ -0,0 +1,265 @@
|
||||
--:Minify:--
|
||||
local kernel = ...
|
||||
|
||||
local proxy = {}
|
||||
local data = {}
|
||||
|
||||
proxy.address = "procfs0000"
|
||||
proxy.isvirt = true
|
||||
proxy.isReadOnly = function() return true end
|
||||
proxy.spaceUsed = function() return 0 end
|
||||
proxy.spaceTotal = function() return 0 end
|
||||
proxy.makeDirectory = function() error("EACCES") end
|
||||
proxy.remove = function() error("EACCES") end
|
||||
proxy.setLabel = function() error("EACCES") end
|
||||
proxy.getLabel = function() return "procfs" end
|
||||
proxy.attributes = function(path) return {
|
||||
size = 0,
|
||||
modified = 0,
|
||||
created = 0
|
||||
} end
|
||||
|
||||
local function buildMeta(entries, opts)
|
||||
opts = opts or {}
|
||||
local uid = opts.uid or 0
|
||||
local gid = opts.gid or 0
|
||||
local perms = opts.perms or 0x3F -- default read/write for owner/group/world
|
||||
|
||||
local chunks = {}
|
||||
table.insert(chunks, string.char(0x02)) -- version header
|
||||
|
||||
for path, target in pairs(entries) do
|
||||
local name = path
|
||||
local nameLen = #name
|
||||
if nameLen > 255 then
|
||||
error("Filename too long (>255 bytes): "..name)
|
||||
end
|
||||
|
||||
-- Determine entry type: 0x01 = symlink if target ~= nil and target ~= ""
|
||||
local entryType = 0x00
|
||||
local cmeta = ""
|
||||
if target and target ~= "" then
|
||||
entryType = 0x01
|
||||
cmeta = target
|
||||
end
|
||||
local cmetaLen = #cmeta
|
||||
if cmetaLen > 255 then
|
||||
error("cmeta too long (>255 bytes) for "..name)
|
||||
end
|
||||
|
||||
-- Build entry as bytes
|
||||
table.insert(chunks, string.char(nameLen)) -- name length
|
||||
table.insert(chunks, name) -- name
|
||||
table.insert(chunks, string.char(entryType)) -- entry type
|
||||
table.insert(chunks, string.char(uid % 256, math.floor(uid/256) % 256)) -- uid
|
||||
table.insert(chunks, string.char(gid % 256, math.floor(gid/256) % 256)) -- gid
|
||||
table.insert(chunks, string.char(perms % 256, math.floor(perms/256) % 256)) -- perms
|
||||
table.insert(chunks, string.char(cmetaLen)) -- cmeta length
|
||||
if cmetaLen > 0 then
|
||||
table.insert(chunks, cmeta)
|
||||
end
|
||||
end
|
||||
|
||||
return table.concat(chunks)
|
||||
end
|
||||
|
||||
local function simpleFile(r,w)
|
||||
return function(op, mode)
|
||||
if op=="type" then
|
||||
return "character device"
|
||||
elseif op=="open" then
|
||||
if mode=="r" then
|
||||
return {
|
||||
read=r
|
||||
}
|
||||
elseif mode=="w" then
|
||||
return {
|
||||
write=w
|
||||
}
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
local function strFile(str)
|
||||
local dat=tostring(str)
|
||||
local pos=1
|
||||
return simpleFile(function(amount)
|
||||
pos=pos+amount
|
||||
return dat:sub(pos-amount, pos)
|
||||
end,function() error("EACCES") end)
|
||||
end
|
||||
|
||||
local function newtaskproxy(task)
|
||||
local files,siblings,children={},{},{}
|
||||
if task.fd[0] then files["0"]=task.fd[0].path end
|
||||
for i,v in ipairs(task.fd) do
|
||||
files[tostring(i)]=tostring(v.path)
|
||||
end
|
||||
for i,v in ipairs(task.siblings) do
|
||||
siblings[tostring(v.pid)]="/proc/"..tostring(v.pid)
|
||||
end
|
||||
for i,v in ipairs(task.children) do
|
||||
children[tostring(v.pid)]="/proc/"..tostring(v.pid)
|
||||
end
|
||||
return {
|
||||
[".meta"]=strFile(buildMeta({cwd=task.cwd,parent="/proc/"..tostring(task.parent.pid)})),
|
||||
uid=strFile(task.uid),
|
||||
comm=strFile(task.name),
|
||||
fd={
|
||||
[".meta"]=strFile(buildMeta(files))
|
||||
},
|
||||
siblings={
|
||||
[".meta"]=strFile(buildMeta(siblings))
|
||||
},
|
||||
children={
|
||||
[".meta"]=strFile(buildMeta(children))
|
||||
}
|
||||
}
|
||||
end
|
||||
|
||||
function proxy:open(path, mode)
|
||||
local steps = kernel.vfs.splitPath(path)
|
||||
local step = data
|
||||
if tonumber(steps[1]) then
|
||||
local task=kernel.tasks[tostring(steps[1])]
|
||||
local step = newtaskproxy(task)
|
||||
for i=2, #steps-1 do
|
||||
local dat = step[steps[i]]
|
||||
if type(dat) ~= "table" then error("ENFILE") end
|
||||
step=dat
|
||||
end
|
||||
if type(step[steps[#steps]]) == "function" then
|
||||
return step[steps[#steps]]("open", mode)
|
||||
end
|
||||
elseif tostring(steps[1])=="self" then
|
||||
local task=kernel.currentTask
|
||||
local step = newtaskproxy(task)
|
||||
for i=2, #steps-1 do
|
||||
local dat = step[steps[i]]
|
||||
if type(dat) ~= "table" then error("ENFILE") end
|
||||
step=dat
|
||||
end
|
||||
if type(step[steps[#steps]]) == "function" then
|
||||
return step[steps[#steps]]("open", mode)
|
||||
end
|
||||
else
|
||||
for i=1, #steps-1 do
|
||||
local dat = step[steps[i]]
|
||||
if type(dat) ~= "table" then error("ENFILE") end
|
||||
step=dat
|
||||
end
|
||||
if type(step[steps[#steps]]) == "function" then
|
||||
return step[steps[#steps]]("open", mode)
|
||||
end
|
||||
end
|
||||
error("ENFILE")
|
||||
end
|
||||
|
||||
function proxy:type(path, mode)
|
||||
local steps = kernel.vfs.splitPath(path)
|
||||
local step = data
|
||||
if #steps == 0 then
|
||||
return "directory"
|
||||
end
|
||||
if tonumber(steps[1]) then
|
||||
local task=kernel.tasks[steps[1]]
|
||||
if #steps==1 then return "directory" end
|
||||
local step = newtaskproxy(task)
|
||||
for i=2, #steps-1 do
|
||||
local dat = step[steps[i]]
|
||||
if type(dat) ~= "table" then error("ENFILE") end
|
||||
step=dat
|
||||
end
|
||||
if type(step[steps[#steps]]) == "function" then
|
||||
return step[steps[#steps]]("type", mode)
|
||||
end
|
||||
if type(step[steps[#steps]]) == "table" then
|
||||
return "directory"
|
||||
end
|
||||
elseif tostring(steps[1])=="self" then
|
||||
local task=kernel.currentTask
|
||||
if #steps==1 then return "directory" end
|
||||
local step = newtaskproxy(task)
|
||||
for i=2, #steps-1 do
|
||||
local dat = step[steps[i]]
|
||||
if type(dat) ~= "table" then error("ENFILE") end
|
||||
step=dat
|
||||
end
|
||||
if type(step[steps[#steps]]) == "function" then
|
||||
return step[steps[#steps]]("type", mode)
|
||||
end
|
||||
if type(step[steps[#steps]]) == "table" then
|
||||
return "directory"
|
||||
end
|
||||
else
|
||||
for i=1, #steps-1 do
|
||||
local dat = step[steps[i]]
|
||||
if type(dat) ~= "table" then error("ENFILE") end
|
||||
step=dat
|
||||
end
|
||||
if type(step[steps[#steps]]) == "function" then
|
||||
return step[steps[#steps]]("type", mode)
|
||||
end
|
||||
if type(step[steps[#steps]]) == "table" then
|
||||
return "directory"
|
||||
end
|
||||
end
|
||||
error("ENOENT")
|
||||
end
|
||||
|
||||
function proxy:list(path)
|
||||
local steps = kernel.vfs.splitPath(path)
|
||||
local step = data
|
||||
if #steps == 0 then
|
||||
return table.merge(table.keys(data),table.keys(kernel.tasks),{"self"})
|
||||
end
|
||||
if tonumber(steps[1]) then
|
||||
local task=kernel.tasks[steps[1]]
|
||||
local step = newtaskproxy(task)
|
||||
if #steps==1 then return table.keys(step) end
|
||||
for i=2, #steps-1 do
|
||||
local dat = step[steps[i]]
|
||||
if type(dat) ~= "table" then error("ENOENT") end
|
||||
step=dat
|
||||
end
|
||||
if type(step[steps[#steps]]) == "table" then
|
||||
return table.keys(step[steps[#steps]])
|
||||
end
|
||||
elseif tostring(steps[1])=="self" then
|
||||
local task=kernel.currentTask
|
||||
local step = newtaskproxy(task)
|
||||
if #steps==1 then return table.keys(step) end
|
||||
for i=2, #steps-1 do
|
||||
local dat = step[steps[i]]
|
||||
if type(dat) ~= "table" then error("ENOENT") end
|
||||
step=dat
|
||||
end
|
||||
if type(step[steps[#steps]]) == "table" then
|
||||
return table.keys(step[steps[#steps]])
|
||||
end
|
||||
else
|
||||
for i=1, #steps-1 do
|
||||
local dat = step[steps[i]]
|
||||
if type(dat) ~= "table" then error("ENOENT") end
|
||||
step=dat
|
||||
end
|
||||
if type(step[steps[#steps]]) == "table" then
|
||||
return table.keys(step[steps[#steps]])
|
||||
end
|
||||
end
|
||||
error("ENOENT")
|
||||
end
|
||||
|
||||
function proxy:fileExists(path)
|
||||
local ok = pcall(function()
|
||||
return self:type(path)
|
||||
end)
|
||||
return ok
|
||||
end
|
||||
|
||||
data.uptime=simpleFile(function()return tostring(kernel.EFI:getUptime())end,function()error("EACCES")end)
|
||||
kernel.procfs={}
|
||||
kernel.procfs.data=data
|
||||
kernel.procfs.proxy=proxy
|
||||
kernel.disks["procfs0000"]=proxy
|
||||
@@ -0,0 +1,134 @@
|
||||
--:Minify:--
|
||||
local kernel = ...
|
||||
|
||||
local proxy = {}
|
||||
local data = {}
|
||||
|
||||
proxy.address = "tmpfs0000"
|
||||
proxy.isvirt = true
|
||||
proxy.isReadOnly = function() return false end
|
||||
|
||||
proxy.spaceUsed = function() return 0 end
|
||||
proxy.spaceTotal = function() return 0 end
|
||||
|
||||
proxy.makeDirectory = function(_, path)
|
||||
local steps = kernel.vfs.splitPath(path)
|
||||
local step = data
|
||||
for i=1,#steps do
|
||||
if not step[steps[i]] then
|
||||
step[steps[i]] = {}
|
||||
elseif type(step[steps[i]]) ~= "table" then
|
||||
error("ENOTDIR")
|
||||
end
|
||||
step = step[steps[i]]
|
||||
end
|
||||
end
|
||||
|
||||
proxy.remove = function(_, path)
|
||||
local steps = kernel.vfs.splitPath(path)
|
||||
local step = data
|
||||
for i=1,#steps-1 do
|
||||
step = step[steps[i]]
|
||||
if not step then error("ENOENT") end
|
||||
end
|
||||
step[steps[#steps]] = nil
|
||||
end
|
||||
|
||||
proxy.setLabel = function(_, label) end
|
||||
proxy.getLabel = function() return "tmpfs" end
|
||||
|
||||
proxy.attributes = function(_, path)
|
||||
local steps = kernel.vfs.splitPath(path)
|
||||
local step = data
|
||||
for i=1,#steps do
|
||||
step = step[steps[i]]
|
||||
if not step then error("ENOENT") end
|
||||
end
|
||||
return {
|
||||
size = type(step) == "string" and #step or 0,
|
||||
modified = 0,
|
||||
created = 0,
|
||||
}
|
||||
end
|
||||
|
||||
function proxy:open(path, mode)
|
||||
local steps = kernel.vfs.splitPath(path)
|
||||
local step = data
|
||||
for i=1,#steps-1 do
|
||||
if not step[steps[i]] then
|
||||
if mode == "w" then step[steps[i]] = {} else error("ENOENT") end
|
||||
elseif type(step[steps[i]]) ~= "table" then
|
||||
error("ENOTDIR")
|
||||
end
|
||||
step = step[steps[i]]
|
||||
end
|
||||
local filename = steps[#steps]
|
||||
|
||||
if mode == "r" then
|
||||
if type(step[filename]) ~= "string" then error("ENOENT") end
|
||||
local content = step[filename]
|
||||
local pos = 1
|
||||
return {
|
||||
read = function(amount)
|
||||
amount = amount or #content
|
||||
local chunk = content:sub(pos, pos+amount-1)
|
||||
pos = pos + #chunk
|
||||
return chunk
|
||||
end,
|
||||
close = function() end,
|
||||
}
|
||||
elseif mode == "w" then
|
||||
step[filename] = ""
|
||||
local buf = {}
|
||||
return {
|
||||
write = function(str)
|
||||
buf[#buf + 1] = str
|
||||
end,
|
||||
close = function()
|
||||
step[filename] = table.concat(buf)
|
||||
end,
|
||||
}
|
||||
elseif mode == "a" then
|
||||
if type(step[filename]) ~= "string" then step[filename] = "" end
|
||||
return {
|
||||
write = function(str)
|
||||
step[filename] = step[filename] .. str
|
||||
end,
|
||||
close = function() end,
|
||||
}
|
||||
else
|
||||
error("EACCES")
|
||||
end
|
||||
end
|
||||
|
||||
function proxy:type(path)
|
||||
local steps = kernel.vfs.splitPath(path)
|
||||
local step = data
|
||||
if #steps == 0 then return "directory" end
|
||||
for i=1,#steps do
|
||||
step = step[steps[i]]
|
||||
if not step then return false end
|
||||
end
|
||||
if type(step) == "table" then return "directory" end
|
||||
if type(step) == "string" then return "file" end
|
||||
end
|
||||
|
||||
function proxy:list(path)
|
||||
local steps = kernel.vfs.splitPath(path)
|
||||
local step = data
|
||||
for i=1,#steps do
|
||||
step = step[steps[i]]
|
||||
if not step then error("ENOENT") end
|
||||
end
|
||||
if type(step) ~= "table" then error("ENOTDIR") end
|
||||
local keys = {}
|
||||
for k,_ in pairs(step) do table.insert(keys, k) end
|
||||
return keys
|
||||
end
|
||||
|
||||
function proxy:fileExists(path)
|
||||
local t = self:type(path)
|
||||
return t == "file" or t == "directory"
|
||||
end
|
||||
|
||||
kernel.disks["tmpfs0000"] = proxy
|
||||
@@ -0,0 +1,540 @@
|
||||
--:Minify:--
|
||||
-- Loop device driver:
|
||||
--
|
||||
-- BIND (directory) - re-routes VFS calls into a host directory subtree.
|
||||
-- Identical to the original behaviour.
|
||||
--
|
||||
-- IMAGE (*.hfs file) - mounts a Hyperion Filesystem Image. The image is
|
||||
-- loaded entirely into memory; reads and writes operate
|
||||
-- on the in-memory tree, so the image file is only
|
||||
-- touched on attach/detach.
|
||||
--
|
||||
-- BHFS v1 - Binary Hyperion Filesystem Image format:
|
||||
--
|
||||
-- File header (8 bytes):
|
||||
-- [0-3] magic: 0x42 0x48 0x46 0x53 ("BHFS")
|
||||
-- [4] version: 0x01
|
||||
-- [5] flags: bit0 = per-file deflate compression enabled
|
||||
-- [6-7] reserved: 0x00 0x00
|
||||
--
|
||||
-- Records (repeated until END record):
|
||||
-- [0] type: 0x01=file 0x02=dir 0x03=symlink 0xFF=end
|
||||
-- [1-4] path_len (uint32 LE) - byte length of the path string
|
||||
-- [5-8] raw_size (uint32 LE) - original uncompressed data size (0 for dirs)
|
||||
-- [9-12] stored_size (uint32 LE) - bytes that follow in stream
|
||||
-- (< raw_size means deflate-compressed;
|
||||
-- = raw_size means stored as-is)
|
||||
-- [13 .. 13+path_len-1] path bytes (no null terminator)
|
||||
-- [.. +stored_size] data bytes
|
||||
--
|
||||
-- Dirs have raw_size=0, stored_size=0, zero data bytes.
|
||||
-- Symlinks store the target path as data; stored_size == raw_size (no compression).
|
||||
--
|
||||
-- Syscalls:
|
||||
-- id = syscall.losetup(path) attach dir OR .hfs image
|
||||
-- id = syscall.losetup(path, true) force image mode
|
||||
-- syscall.lodetach(id) detach (must be unmounted first)
|
||||
-- tbl = syscall.lolist() {id -> {path,mode}, ...}
|
||||
-- str = syscall.loimgcreate(srcdir) serialise VFS dir -> BHFS binary string
|
||||
-- syscall.loimgwrite(str, dest) write BHFS string to a file (binary)
|
||||
|
||||
local kernel = ...
|
||||
|
||||
local _deflate = nil
|
||||
local function getDeflate()
|
||||
if _deflate == nil then
|
||||
local ok, lib = pcall(require, "store.deflate")
|
||||
_deflate = ok and lib or false
|
||||
end
|
||||
return _deflate or nil
|
||||
end
|
||||
|
||||
local function pack32(n)
|
||||
n = math.floor(n) % 4294967296
|
||||
return string.char(
|
||||
n % 256,
|
||||
math.floor(n / 256) % 256,
|
||||
math.floor(n / 65536) % 256,
|
||||
math.floor(n / 16777216) % 256
|
||||
)
|
||||
end
|
||||
|
||||
local function unpack32(s, i)
|
||||
local a, b, c, d = s:byte(i, i + 3)
|
||||
return (a or 0)
|
||||
+ (b or 0) * 256
|
||||
+ (c or 0) * 65536
|
||||
+ (d or 0) * 16777216
|
||||
end
|
||||
|
||||
local BHFS_MAGIC = "BHFS"
|
||||
local BHFS_VERSION = "\001"
|
||||
local BHFS_FLAG_COMPRESS = 1
|
||||
|
||||
local TYPE_FILE = "\001"
|
||||
local TYPE_DIR = "\002"
|
||||
local TYPE_LINK = "\003"
|
||||
local TYPE_END = "\255"
|
||||
|
||||
local B64D = {}
|
||||
do
|
||||
local a = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
|
||||
for i = 1, #a do B64D[a:sub(i, i)] = i - 1 end
|
||||
end
|
||||
|
||||
local function b64dec(s)
|
||||
s = s:gsub("[^A-Za-z0-9+/=]", "")
|
||||
local t, i = {}, 1
|
||||
while i <= #s do
|
||||
local c1 = B64D[s:sub(i, i )] or 0
|
||||
local c2 = B64D[s:sub(i+1, i+1)] or 0
|
||||
local c3 = B64D[s:sub(i+2, i+2)] or 0
|
||||
local c4 = B64D[s:sub(i+3, i+3)] or 0
|
||||
local n = c1*262144 + c2*4096 + c3*64 + c4
|
||||
t[#t+1] = string.char(math.floor(n/65536) % 256)
|
||||
if s:sub(i+2, i+2) ~= "=" then t[#t+1] = string.char(math.floor(n/256) % 256) end
|
||||
if s:sub(i+3, i+3) ~= "=" then t[#t+1] = string.char(n % 256) end
|
||||
i = i + 4
|
||||
end
|
||||
return table.concat(t)
|
||||
end
|
||||
|
||||
local loopDevs = {}
|
||||
local nextLoop = 0
|
||||
|
||||
local function makeBindDisk(id, dirPath)
|
||||
local disk = { address = id, isvirt = false }
|
||||
disk.isReadOnly = function() return false end
|
||||
disk.spaceUsed = function() return 0 end
|
||||
disk.spaceTotal = function() return 0 end
|
||||
disk.setLabel = function() end
|
||||
disk.getLabel = function() return id end
|
||||
|
||||
local function resolveBase()
|
||||
local mp, mid = "/", "$"
|
||||
for id2, m in pairs(kernel.vfs.mounts) do
|
||||
if dirPath == m or (m == "/" and dirPath:sub(1,1) == "/")
|
||||
or dirPath:sub(1, #m+1) == m.."/" then
|
||||
if #m > #mp then mp = m; mid = id2 end
|
||||
end
|
||||
end
|
||||
return kernel.vfs.disks[mid], dirPath:sub(#mp+1)
|
||||
end
|
||||
|
||||
local function dp(path)
|
||||
local hd, base = resolveBase()
|
||||
local b = (base == "" or base == "/") and "" or base:gsub("^/+","")
|
||||
local p = path:gsub("^/+","")
|
||||
local c = ((b=="") and "/"..p or "/"..b.."/"..p):gsub("//+","/")
|
||||
local r = c:sub(2); if r == "" then r = "/" end
|
||||
return hd, r
|
||||
end
|
||||
|
||||
function disk:open(path,mode) local h,r=dp(path); return h:open(r,mode) end
|
||||
function disk:type(path) local h,r=dp(path); return h:type(r) end
|
||||
function disk:list(path) local h,r=dp(path); return h:list(r) end
|
||||
function disk:fileExists(path) local h,r=dp(path); return h:fileExists(r) end
|
||||
function disk:attributes(path) local h,r=dp(path); return h:attributes(r) end
|
||||
function disk:makeDirectory(path) local h,r=dp(path); return h:makeDirectory(r) end
|
||||
function disk:remove(path) local h,r=dp(path); return h:remove(r) end
|
||||
return disk
|
||||
end
|
||||
|
||||
local function makeImageDisk(id, imageStr)
|
||||
local root = { kind="dir", children={} }
|
||||
|
||||
local function getNode(path, create)
|
||||
local parts = {}
|
||||
for p in path:gmatch("[^/]+") do parts[#parts+1] = p end
|
||||
local node = root
|
||||
for i = 1, #parts do
|
||||
local name = parts[i]
|
||||
if not node.children then
|
||||
if not create then return nil end
|
||||
node.children = {}
|
||||
end
|
||||
if not node.children[name] then
|
||||
if not create then return nil end
|
||||
node.children[name] = { kind="dir", children={} }
|
||||
end
|
||||
node = node.children[name]
|
||||
end
|
||||
return node
|
||||
end
|
||||
|
||||
local function ensureParent(path)
|
||||
local par = path:match("^(.*)/[^/]+$") or ""
|
||||
if par ~= "" then
|
||||
local n = getNode(par, true)
|
||||
if not n.children then n.children = {} end
|
||||
end
|
||||
end
|
||||
|
||||
if imageStr:sub(1, 4) == BHFS_MAGIC then
|
||||
local pos = 9
|
||||
|
||||
while pos <= #imageStr do
|
||||
local rtype = imageStr:sub(pos, pos)
|
||||
pos = pos + 1
|
||||
|
||||
if rtype == TYPE_END then break end
|
||||
|
||||
local path_len = unpack32(imageStr, pos); pos = pos + 4
|
||||
local raw_size = unpack32(imageStr, pos); pos = pos + 4
|
||||
local stored_size = unpack32(imageStr, pos); pos = pos + 4
|
||||
|
||||
local path = imageStr:sub(pos, pos + path_len - 1)
|
||||
pos = pos + path_len
|
||||
|
||||
local stored_data = imageStr:sub(pos, pos + stored_size - 1)
|
||||
pos = pos + stored_size
|
||||
local data = stored_data
|
||||
if stored_size < raw_size then
|
||||
local deflate = getDeflate()
|
||||
if deflate then
|
||||
data = deflate.decompress(stored_data) or stored_data
|
||||
end
|
||||
end
|
||||
|
||||
if rtype == TYPE_DIR then
|
||||
if path ~= "" and path ~= "/" then
|
||||
ensureParent(path)
|
||||
local n = getNode(path, true)
|
||||
n.kind = "dir"; n.children = n.children or {}
|
||||
end
|
||||
elseif rtype == TYPE_FILE then
|
||||
ensureParent(path)
|
||||
local n = getNode(path, true)
|
||||
n.kind="file"; n.data=data; n.size=#data; n.children=nil
|
||||
elseif rtype == TYPE_LINK then
|
||||
ensureParent(path)
|
||||
local n = getNode(path, true)
|
||||
n.kind="link"; n.target=data; n.children=nil
|
||||
end
|
||||
end
|
||||
else
|
||||
for line in (imageStr.."\n"):gmatch("([^\n]*)\n") do
|
||||
if line == "END" then
|
||||
break
|
||||
elseif line:sub(1,4) == "DIR " then
|
||||
local p = line:sub(5):match("^%s*(.-)%s*$")
|
||||
if p and p ~= "" and p ~= "/" then
|
||||
ensureParent(p)
|
||||
local n = getNode(p, true)
|
||||
n.kind = "dir"; n.children = n.children or {}
|
||||
end
|
||||
elseif line:sub(1,5) == "FILE " then
|
||||
local p, sz, body = line:sub(6):match("^(%S+)%s+(%d+)%s*(.-)%s*$")
|
||||
if p then
|
||||
ensureParent(p)
|
||||
local data = (tonumber(sz) or 0) > 0 and b64dec(body) or ""
|
||||
local n = getNode(p, true)
|
||||
n.kind="file"; n.data=data; n.size=#data; n.children=nil
|
||||
end
|
||||
elseif line:sub(1,5) == "LINK " then
|
||||
local p, tgt = line:sub(6):match("^(%S+)%s+(.+)$")
|
||||
if p then
|
||||
ensureParent(p)
|
||||
local n = getNode(p, true)
|
||||
n.kind="link"; n.target=tgt; n.children=nil
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
local disk = { address=id, isvirt=false }
|
||||
disk.isReadOnly = function() return false end
|
||||
disk.spaceTotal = function() return 1024*1024*64 end
|
||||
disk.spaceUsed = function()
|
||||
local tot = 0
|
||||
local function w(n)
|
||||
if n.kind=="file" then tot = tot + (n.size or 0)
|
||||
elseif n.kind=="dir" then for _,c in pairs(n.children or {}) do w(c) end end
|
||||
end
|
||||
w(root); return tot
|
||||
end
|
||||
disk.setLabel = function() end
|
||||
disk.getLabel = function() return id end
|
||||
|
||||
local function norm(path)
|
||||
return path:gsub("^/+",""):gsub("/+$","")
|
||||
end
|
||||
|
||||
function disk:type(path)
|
||||
local p = norm(path)
|
||||
if p == "" then return "directory" end
|
||||
local n = getNode(p)
|
||||
if not n then return nil end
|
||||
if n.kind == "dir" then return "directory" end
|
||||
return "file"
|
||||
end
|
||||
|
||||
function disk:fileExists(path)
|
||||
local p = norm(path)
|
||||
if p == "" then return true end
|
||||
return getNode(p) ~= nil
|
||||
end
|
||||
|
||||
function disk:list(path)
|
||||
local p = norm(path)
|
||||
local node = (p=="") and root or getNode(p)
|
||||
if not node or node.kind ~= "dir" then return {} end
|
||||
local out = {}
|
||||
for name in pairs(node.children or {}) do out[#out+1] = name end
|
||||
return out
|
||||
end
|
||||
|
||||
function disk:attributes(path)
|
||||
local p = norm(path)
|
||||
local node = (p=="") and root or getNode(p)
|
||||
if not node then return nil end
|
||||
return {
|
||||
size = node.kind=="file" and (node.size or 0) or 0,
|
||||
isDir = node.kind=="dir",
|
||||
isReadOnly = false,
|
||||
created = 0,
|
||||
modified = 0,
|
||||
}
|
||||
end
|
||||
|
||||
function disk:open(path, mode)
|
||||
local p = norm(path)
|
||||
local node = getNode(p)
|
||||
|
||||
if mode == "r" then
|
||||
if not node or node.kind ~= "file" then error("ENOENT: "..path) end
|
||||
local data, pos = node.data or "", 1
|
||||
return {
|
||||
read = function(n)
|
||||
if pos > #data then return nil end
|
||||
local chunk = data:sub(pos, pos + (n or 1) - 1)
|
||||
pos = pos + #chunk; return chunk
|
||||
end,
|
||||
readAll = function()
|
||||
local all = data:sub(pos); pos = #data + 1; return all
|
||||
end,
|
||||
readLine = function()
|
||||
if pos > #data then return nil end
|
||||
local nl = data:find("\n", pos, true)
|
||||
local line
|
||||
if nl then line=data:sub(pos, nl-1); pos=nl+1
|
||||
else line=data:sub(pos); pos=#data+1 end
|
||||
return line
|
||||
end,
|
||||
seek = function(w, o)
|
||||
o = o or 0
|
||||
if w == "set" then pos = o + 1
|
||||
elseif w == "cur" then pos = pos + o
|
||||
elseif w == "end" then pos = #data + 1 + o end
|
||||
return pos - 1
|
||||
end,
|
||||
close = function() end,
|
||||
}
|
||||
|
||||
elseif mode == "w" or mode == "a" then
|
||||
local buf = (mode=="a" and node and node.kind=="file")
|
||||
and {node.data or ""} or {}
|
||||
local done = false
|
||||
local function commit()
|
||||
if done then return end; done = true
|
||||
local data = table.concat(buf)
|
||||
if not node then ensureParent(p); node = getNode(p, true) end
|
||||
node.kind="file"; node.data=data; node.size=#data; node.children=nil
|
||||
end
|
||||
return {
|
||||
write = function(s) buf[#buf+1] = tostring(s) end,
|
||||
writeLine = function(s) buf[#buf+1] = tostring(s).."\n" end,
|
||||
flush = function() end,
|
||||
close = commit,
|
||||
}
|
||||
else
|
||||
error("EINVAL: unknown mode: "..tostring(mode))
|
||||
end
|
||||
end
|
||||
|
||||
function disk:makeDirectory(path)
|
||||
local p = norm(path)
|
||||
if p == "" then return end
|
||||
ensureParent(p)
|
||||
local n = getNode(p, true)
|
||||
n.kind="dir"; n.children=n.children or {}; n.data=nil; n.size=nil
|
||||
end
|
||||
|
||||
function disk:remove(path)
|
||||
local p = norm(path)
|
||||
if p == "" then error("EBUSY: cannot remove root") end
|
||||
local par = p:match("^(.*)/[^/]+$") or ""
|
||||
local name = p:match("([^/]+)$")
|
||||
local pn = (par=="") and root or getNode(par)
|
||||
if pn and pn.children then pn.children[name] = nil end
|
||||
end
|
||||
|
||||
disk._root = root
|
||||
return disk
|
||||
end
|
||||
|
||||
local function serializeDir(srcPath)
|
||||
local deflate = getDeflate()
|
||||
local useCompress = deflate ~= nil
|
||||
|
||||
local flags = useCompress and BHFS_FLAG_COMPRESS or 0
|
||||
local parts = {
|
||||
BHFS_MAGIC,
|
||||
BHFS_VERSION,
|
||||
string.char(flags),
|
||||
"\0\0",
|
||||
}
|
||||
|
||||
srcPath = srcPath:gsub("/$", "")
|
||||
|
||||
local MIN_COMPRESS = 64
|
||||
|
||||
local function walk(vpath)
|
||||
local ftype = kernel.vfs.type(vpath)
|
||||
|
||||
if ftype == "directory" then
|
||||
if vpath ~= srcPath then
|
||||
local relPath = vpath:sub(#srcPath + 1)
|
||||
parts[#parts+1] = TYPE_DIR
|
||||
parts[#parts+1] = pack32(#relPath)
|
||||
parts[#parts+1] = pack32(0)
|
||||
parts[#parts+1] = pack32(0)
|
||||
parts[#parts+1] = relPath
|
||||
end
|
||||
local ok, entries = pcall(kernel.vfs.listdir, vpath)
|
||||
if ok and entries then
|
||||
table.sort(entries)
|
||||
for _, name in ipairs(entries) do
|
||||
walk(vpath:gsub("/$","").."/"..name)
|
||||
end
|
||||
end
|
||||
|
||||
elseif ftype == "file" then
|
||||
local relPath = vpath:sub(#srcPath + 1)
|
||||
local ok, fd = pcall(kernel.vfs.open, vpath, "r")
|
||||
if ok then
|
||||
local rawData = ""
|
||||
local ok2, content = pcall(kernel.vfs.read, fd, 1024*1024)
|
||||
if ok2 then rawData = content or "" end
|
||||
pcall(kernel.vfs.close, fd)
|
||||
|
||||
local storedData = rawData
|
||||
if useCompress and #rawData >= MIN_COMPRESS then
|
||||
local compressed = deflate.compress(rawData)
|
||||
if compressed and #compressed < #rawData then
|
||||
storedData = compressed
|
||||
end
|
||||
end
|
||||
|
||||
parts[#parts+1] = TYPE_FILE
|
||||
parts[#parts+1] = pack32(#relPath)
|
||||
parts[#parts+1] = pack32(#rawData)
|
||||
parts[#parts+1] = pack32(#storedData)
|
||||
parts[#parts+1] = relPath
|
||||
parts[#parts+1] = storedData
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
walk(srcPath)
|
||||
|
||||
parts[#parts+1] = TYPE_END
|
||||
|
||||
return table.concat(parts)
|
||||
end
|
||||
|
||||
kernel.syscalls["losetup"] = function(filePath, forceImage)
|
||||
if not filePath then error("EINVAL") end
|
||||
local task = kernel.currentTask
|
||||
local euid = (task and (task.euid or task.uid)) or kernel.uid
|
||||
if euid ~= 0 then error("EPERM") end
|
||||
|
||||
filePath = filePath:gsub("/$", "")
|
||||
local id = "loop" .. tostring(nextLoop)
|
||||
nextLoop = nextLoop + 1
|
||||
|
||||
local ftype = kernel.vfs.type(filePath)
|
||||
local disk, mode
|
||||
|
||||
if not forceImage and ftype == "directory" then
|
||||
disk = makeBindDisk(id, filePath)
|
||||
mode = "bind"
|
||||
elseif ftype == "file" or forceImage then
|
||||
if ftype ~= "file" then error("ENOENT: not a file: "..filePath) end
|
||||
|
||||
local img
|
||||
local ok, fd = pcall(kernel.vfs.open, filePath, "rb")
|
||||
if ok then
|
||||
local ok2, data = pcall(kernel.vfs.read, fd, 1024*1024*16)
|
||||
pcall(kernel.vfs.close, fd)
|
||||
if ok2 and data then img = data end
|
||||
end
|
||||
if not img then
|
||||
local ok2, fd2 = pcall(kernel.vfs.open, filePath, "r")
|
||||
if not ok2 then error("EIO: cannot open image: "..filePath) end
|
||||
local ok3, data = pcall(kernel.vfs.read, fd2, 1024*1024*16)
|
||||
pcall(kernel.vfs.close, fd2)
|
||||
if not ok3 or not data then error("EIO: cannot read image: "..filePath) end
|
||||
img = data
|
||||
end
|
||||
|
||||
disk = makeImageDisk(id, img)
|
||||
mode = "image"
|
||||
else
|
||||
error("EINVAL: path must be a directory or .hfs image file")
|
||||
end
|
||||
|
||||
kernel.vfs.disks[id] = disk
|
||||
loopDevs[id] = { path=filePath, disk=disk, mode=mode }
|
||||
kernel.log("losetup: attached "..id.." ("..mode..") -> "..filePath, "INFO")
|
||||
return id
|
||||
end
|
||||
|
||||
kernel.syscalls["lodetach"] = function(id)
|
||||
local task = kernel.currentTask
|
||||
local euid = (task and (task.euid or task.uid)) or kernel.uid
|
||||
if euid ~= 0 then error("EPERM") end
|
||||
|
||||
if not loopDevs[id] then error("ENXIO") end
|
||||
for mid in pairs(kernel.vfs.mounts) do
|
||||
if mid == id then error("EBUSY: loop device is still mounted") end
|
||||
end
|
||||
kernel.vfs.disks[id] = nil
|
||||
loopDevs[id] = nil
|
||||
kernel.log("lodetach: detached "..id, "INFO")
|
||||
end
|
||||
|
||||
kernel.syscalls["lolist"] = function()
|
||||
local rv = {}
|
||||
for id, info in pairs(loopDevs) do
|
||||
rv[id] = { path=info.path, mode=info.mode }
|
||||
end
|
||||
return rv
|
||||
end
|
||||
|
||||
kernel.syscalls["loimgcreate"] = function(srcPath)
|
||||
local task = kernel.currentTask
|
||||
local euid = (task and (task.euid or task.uid)) or kernel.uid
|
||||
if euid ~= 0 then error("EPERM") end
|
||||
if not srcPath then error("EINVAL") end
|
||||
if kernel.vfs.type(srcPath) ~= "directory" then error("ENOTDIR: "..srcPath) end
|
||||
return serializeDir(srcPath)
|
||||
end
|
||||
|
||||
kernel.syscalls["loimgwrite"] = function(imgStr, destPath)
|
||||
local task = kernel.currentTask
|
||||
local euid = (task and (task.euid or task.uid)) or kernel.uid
|
||||
if euid ~= 0 then error("EPERM") end
|
||||
if not imgStr or not destPath then error("EINVAL") end
|
||||
|
||||
local ok, fd = pcall(kernel.vfs.open, destPath, "wb")
|
||||
if not ok then
|
||||
ok, fd = pcall(kernel.vfs.open, destPath, "w")
|
||||
if not ok then error("EIO: cannot write: "..tostring(destPath)) end
|
||||
end
|
||||
local ok2, werr = pcall(kernel.vfs.write, fd, imgStr)
|
||||
pcall(kernel.vfs.close, fd)
|
||||
if not ok2 then error("EIO: write failed: "..tostring(werr)) end
|
||||
end
|
||||
|
||||
kernel.log("Loop device driver loaded (bind + BHFS binary image + legacy HFS compat)")
|
||||
@@ -0,0 +1,34 @@
|
||||
--:Minify:--
|
||||
local kernel = ...
|
||||
|
||||
local function trim(str)
|
||||
local s, e = 1, #str
|
||||
while s <= e and (str:sub(s,s) == " " or str:sub(s,s) == "\t") do s = s + 1 end
|
||||
while e >= s and (str:sub(e,e) == " " or str:sub(e,e) == "\t" or str:sub(e,e) == "\n" or str:sub(e,e) == "\r") do e = e - 1 end
|
||||
if s > e then return "" end
|
||||
return str:sub(s,e)
|
||||
end
|
||||
|
||||
for _, line in ipairs(string.split(kernel.fstab, "\n")) do
|
||||
line = trim(line)
|
||||
if line ~= "" and line:sub(1,1) == "U" then
|
||||
local semicolon_pos
|
||||
for i = 3, #line do
|
||||
if line:sub(i,i) == ";" then
|
||||
semicolon_pos = i
|
||||
break
|
||||
end
|
||||
end
|
||||
|
||||
if not semicolon_pos or semicolon_pos == 3 then
|
||||
kernel.log("Invalid fstab line: "..line.." ... Skipping.", "WARN", 0xFF8800)
|
||||
else
|
||||
local id = line:sub(3, semicolon_pos - 1)
|
||||
local path = trim(line:sub(semicolon_pos + 1))
|
||||
kernel.log("Mounted "..id.." to "..path)
|
||||
if id ~= "$" then
|
||||
kernel.vfs.mount(path, id)
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,38 @@
|
||||
--:Minify:--
|
||||
local kernel = ...
|
||||
local signal = {}
|
||||
kernel.signal=signal
|
||||
|
||||
function signal.sigsend(pid, sig)
|
||||
if sig<0 or sig>256 then error("EINVAL") end
|
||||
local task = kernel.tasks[tostring(pid)]
|
||||
if not task then error("ENOENT") end
|
||||
if not task.sigq then return end
|
||||
task.sigq[#task.sigq+1] = sig
|
||||
end
|
||||
|
||||
function signal.sigcatch(handler)
|
||||
local task=kernel.currentTask
|
||||
task.sigh=handler
|
||||
if not task.sigq then task.sigq={} end
|
||||
local handle={
|
||||
error="",
|
||||
active=true
|
||||
}
|
||||
if task.sigd then task.sigd.active=false; end
|
||||
task.sigd=handle
|
||||
return handle
|
||||
end
|
||||
|
||||
function signal.sigignore()
|
||||
local task=kernel.currentTask
|
||||
task.sigh=nil
|
||||
task.sigq=nil
|
||||
if task.sigd then task.sigd.active=false end
|
||||
task.sigd=nil
|
||||
end
|
||||
|
||||
local s=kernel.syscalls
|
||||
s["sigsend"] = signal.sigsend
|
||||
s["sigcatch"] = signal.sigcatch
|
||||
s["sigignore"] = signal.sigignore
|
||||
@@ -0,0 +1,67 @@
|
||||
--:Minify:--
|
||||
-- Supports:
|
||||
-- AF_UNIX - local IPC via /var/run/*.sock paths
|
||||
-- AF_INET - network sockets with three backends:
|
||||
-- Implemented by drivers but expect http:// and https://
|
||||
--
|
||||
-- Socket lifecycle:
|
||||
-- fd = syscall.socket(domain, socktype) -- "unix"/"inet", "stream"/"dgram"
|
||||
-- syscall.bind(fd, address) -- server: claim address
|
||||
-- syscall.listen(fd, backlog) -- server: mark as listening
|
||||
-- cfd = syscall.accept(fd) -- server: get connected client fd (blocking poll)
|
||||
-- syscall.connect(fd, address) -- client: connect to server
|
||||
-- syscall.send(fd, data) -- send bytes
|
||||
-- syscall.recv(fd, len) -- receive bytes (blocking poll, returns "" on nothing)
|
||||
-- syscall.sockshutdown(fd) -- half-close send side
|
||||
-- -- normal vfs.close(fd) closes the socket
|
||||
|
||||
local kernel=...
|
||||
local socket={}
|
||||
socket.handlers={}
|
||||
kernel.socket=socket
|
||||
|
||||
function socket.registerProtocal(protocal, handler)
|
||||
socket.handlers[protocal] = handler
|
||||
end
|
||||
|
||||
function socket.socket()
|
||||
local P=kernel.vfs.P
|
||||
local data=kernel.newFifo()
|
||||
local isClosed=false
|
||||
return kernel.vfs.newfd({
|
||||
handle={
|
||||
read=function() if isClosed then error("ECCON") end return data.pop() end,
|
||||
write=function(data) if isClosed then error("ECCON") end return data.push(data) end,
|
||||
close=function() isClosed = true end
|
||||
},
|
||||
type="socket",
|
||||
refcount=1,
|
||||
socket={},
|
||||
meta={
|
||||
owner=kernel.currentTask.uid,
|
||||
group=kernel.currentTask.uid,
|
||||
etype=2,
|
||||
perms=P.OWNER_R+P.OWNER_W+P.GROUP_R+P.GROUP_W
|
||||
},
|
||||
isvirt=true
|
||||
})
|
||||
end
|
||||
|
||||
function socket.connect(fd, address)
|
||||
local handler
|
||||
for k, v in pairs(socket.handlers) do
|
||||
if string.hasPrefix(address, k) then
|
||||
handler=v
|
||||
end
|
||||
end
|
||||
handler.connect(kernel.currentTask.fd[fd], address)
|
||||
end
|
||||
|
||||
function socket.listen(fd, backlog)
|
||||
error("Not Implemented")
|
||||
end
|
||||
|
||||
local sys=kernel.syscalls
|
||||
sys["socket"]=socket.socket
|
||||
|
||||
kernel.log("Loaded socket module")
|
||||
@@ -0,0 +1,4 @@
|
||||
--:Minify:--
|
||||
local kernel=...
|
||||
kernel.unixSockets={}
|
||||
local socket=kernel.socket
|
||||
@@ -0,0 +1,73 @@
|
||||
--:Minify:--
|
||||
local args = {...}
|
||||
local kernel = args[1]
|
||||
kernel._G = _G
|
||||
|
||||
|
||||
local function readonly(tbl)
|
||||
return setmetatable({}, {
|
||||
__index = function(_, key)
|
||||
local value = tbl[key]
|
||||
if type(value) == "table" then return readonly(value) end
|
||||
return value
|
||||
end,
|
||||
|
||||
__newindex = function(t, k, v)
|
||||
if kernel.config.allowGlobalOverwrites or
|
||||
kernel.allowGlobalOverwrites then
|
||||
rawset(tbl, k, v)
|
||||
return
|
||||
end
|
||||
error("Attempt to modify global variable '" .. k .. "'", 2)
|
||||
end,
|
||||
|
||||
__pairs = function(self)
|
||||
local function iter(_, key)
|
||||
local nextKey, value = next(tbl, key)
|
||||
if type(value) == "table" then
|
||||
value = readonly(value)
|
||||
end
|
||||
return nextKey, value
|
||||
end
|
||||
return iter, self, nil
|
||||
end,
|
||||
|
||||
__ipairs = function()
|
||||
local i = 0
|
||||
return function()
|
||||
i = i + 1
|
||||
local value = tbl[i]
|
||||
if value == nil then return end
|
||||
if type(value) == "table" then
|
||||
value = readonly(value)
|
||||
end
|
||||
return i, value
|
||||
end
|
||||
end,
|
||||
|
||||
__len = function() return #tbl end,
|
||||
|
||||
__metatable = false
|
||||
})
|
||||
end
|
||||
local origLoad = load
|
||||
|
||||
kernel._U = readonly(kernel._G)
|
||||
kernel._U._G = kernel._U
|
||||
kernel._U.load = function(a,b,c,d) return origLoad(a,b,c,d or kernel._U) end
|
||||
|
||||
function kernel.freshUserEnv()
|
||||
local locals = {}
|
||||
locals.syscall = _makeSyscallProxy()
|
||||
|
||||
local env = setmetatable(locals, {
|
||||
__index = kernel._U,
|
||||
__newindex = function(_, k, v) rawset(locals, k, v) end,
|
||||
__metatable=false
|
||||
})
|
||||
|
||||
locals._G = env
|
||||
locals.load = function(a, b, c, d) return origLoad(a, b, c, d or env) end
|
||||
|
||||
return env
|
||||
end
|
||||
@@ -0,0 +1,616 @@
|
||||
--:Minify:--
|
||||
local kernel = ...
|
||||
local auth = {}
|
||||
kernel.auth = auth
|
||||
|
||||
-- PASSWD FILE FORMAT: uid:gid:username:homedir:shell
|
||||
-- SHADOW FILE FORMAT: uid:salt:hash
|
||||
|
||||
local function getFile(path)
|
||||
local file = kernel.vfs.open(path, "r")
|
||||
if not file then error("Failed to open file: " .. path) end
|
||||
local content = kernel.vfs.read(file, 1024000)
|
||||
kernel.vfs.close(file)
|
||||
return content
|
||||
end
|
||||
|
||||
local function writeFile(path, content)
|
||||
local file = kernel.vfs.open(path, "w")
|
||||
if not file then error("Failed to open file for writing: " .. path) end
|
||||
kernel.vfs.write(file, content)
|
||||
kernel.vfs.close(file)
|
||||
end
|
||||
|
||||
local blake2s
|
||||
do
|
||||
local MOD32 = 2^32
|
||||
local function norm(x) return x % MOD32 end
|
||||
local function tobits(x)
|
||||
x = norm(x)
|
||||
local t = {}
|
||||
for i = 0, 31 do local b = x % 2; t[i] = b; x = (x - b) / 2 end
|
||||
return t
|
||||
end
|
||||
local function frombits(t)
|
||||
local x, p = 0, 1
|
||||
for i = 0, 31 do if t[i] == 1 then x = x + p end; p = p * 2 end
|
||||
return norm(x)
|
||||
end
|
||||
local function bor(...)
|
||||
local args = {...}
|
||||
if #args == 0 then return 0 end
|
||||
local bits = tobits(args[1])
|
||||
for i = 2, #args do
|
||||
local b = tobits(args[i])
|
||||
for j = 0, 31 do bits[j] = (bits[j] == 1 or b[j] == 1) and 1 or 0 end
|
||||
end
|
||||
return frombits(bits)
|
||||
end
|
||||
local function bxor(...)
|
||||
local args = {...}
|
||||
if #args == 0 then return 0 end
|
||||
local bits = tobits(args[1])
|
||||
for i = 2, #args do
|
||||
local b = tobits(args[i])
|
||||
for j = 0, 31 do bits[j] = (bits[j] ~= b[j]) and 1 or 0 end
|
||||
end
|
||||
return frombits(bits)
|
||||
end
|
||||
local function lshift(x, n) return norm(norm(x) * 2^n) end
|
||||
local function rshift(x, n) return math.floor(norm(x) / 2^n) end
|
||||
local function rotr(x, n) return bor(rshift(x, n), lshift(x, 32 - n)) end
|
||||
local IV = {
|
||||
0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A,
|
||||
0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19
|
||||
}
|
||||
local SIGMA = {
|
||||
{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15},
|
||||
{14,10,4,8,9,15,13,6,1,12,0,2,11,7,5,3},
|
||||
{11,8,12,0,5,2,15,13,10,14,3,6,7,1,9,4},
|
||||
{7,9,3,1,13,12,11,14,2,6,5,10,4,0,15,8},
|
||||
{9,0,5,7,2,4,10,15,14,1,11,12,6,8,3,13},
|
||||
{2,12,6,10,0,11,8,3,4,13,7,5,15,14,1,9},
|
||||
{12,5,1,15,14,13,4,10,0,7,6,3,9,2,8,11},
|
||||
{13,11,7,14,12,1,3,9,5,0,15,4,8,6,2,10},
|
||||
{6,15,14,9,11,3,0,8,12,2,13,7,1,4,10,5},
|
||||
{10,2,8,4,7,6,1,5,15,11,9,14,3,12,13,0}
|
||||
}
|
||||
local function G(v, a, b, c, d, x, y)
|
||||
v[a] = (v[a] + v[b] + x) % MOD32
|
||||
v[d] = rotr(bxor(v[d], v[a]), 16)
|
||||
v[c] = (v[c] + v[d]) % MOD32
|
||||
v[b] = rotr(bxor(v[b], v[c]), 12)
|
||||
v[a] = (v[a] + v[b] + y) % MOD32
|
||||
v[d] = rotr(bxor(v[d], v[a]), 8)
|
||||
v[c] = (v[c] + v[d]) % MOD32
|
||||
v[b] = rotr(bxor(v[b], v[c]), 7)
|
||||
end
|
||||
local function compress(h, block, t, last)
|
||||
local v = {}
|
||||
for i = 1, 8 do v[i] = h[i] end
|
||||
for i = 1, 8 do v[i + 8] = IV[i] end
|
||||
v[13] = bxor(v[13], t)
|
||||
if last then v[15] = bxor(v[15], 0xFFFFFFFF) end
|
||||
local m = {}
|
||||
for i = 0, 15 do
|
||||
local p = i * 4 + 1
|
||||
m[i] = (block:byte(p) or 0)
|
||||
+ ((block:byte(p+1) or 0) * 0x100)
|
||||
+ ((block:byte(p+2) or 0) * 0x10000)
|
||||
+ ((block:byte(p+3) or 0) * 0x1000000)
|
||||
end
|
||||
for r = 1, 10 do
|
||||
local s = SIGMA[r]
|
||||
G(v,1,5,9,13, m[s[1]], m[s[2]])
|
||||
G(v,2,6,10,14, m[s[3]], m[s[4]])
|
||||
G(v,3,7,11,15, m[s[5]], m[s[6]])
|
||||
G(v,4,8,12,16, m[s[7]], m[s[8]])
|
||||
G(v,1,6,11,16, m[s[9]], m[s[10]])
|
||||
G(v,2,7,12,13, m[s[11]], m[s[12]])
|
||||
G(v,3,8,9,14, m[s[13]], m[s[14]])
|
||||
G(v,4,5,10,15, m[s[15]], m[s[16]])
|
||||
end
|
||||
for i = 1, 8 do h[i] = bxor(h[i], v[i], v[i+8]) end
|
||||
end
|
||||
function blake2s(msg, key)
|
||||
key = key or ""
|
||||
local h = {}
|
||||
for i = 1, 8 do h[i] = IV[i] end
|
||||
local outlen = 32
|
||||
h[1] = bxor(h[1], 0x01010000 + lshift(#key, 8) + outlen)
|
||||
local t = 0
|
||||
if #key > 0 then
|
||||
local block = key .. string.rep("\0", 64 - #key)
|
||||
t = #key
|
||||
compress(h, block, t, false)
|
||||
end
|
||||
for i = 1, #msg, 64 do
|
||||
local block = msg:sub(i, i + 63)
|
||||
if #block < 64 then block = block .. string.rep("\0", 64 - #block) end
|
||||
t = t + math.min(64, #msg - i + 1)
|
||||
compress(h, block, t, i + 64 > #msg)
|
||||
end
|
||||
local out = ""
|
||||
for i = 1, 8 do out = out .. string.format("%08x", h[i]) end
|
||||
return out
|
||||
end
|
||||
end
|
||||
|
||||
if not blake2s then error("Failed to load blake2s") end
|
||||
|
||||
if not kernel.vfs.exists("/etc/pam.d/secret") then
|
||||
kernel.log("PAM SECRET REGENERATING PLEASE USE ROOT", "WARN", 0xFF8800)
|
||||
local key = ""
|
||||
for i = 1, 256 do key = key .. string.char(math.random(0, 255)) end
|
||||
local handle = kernel.vfs.open("/etc/pam.d/secret", "w")
|
||||
kernel.vfs.write(handle, key)
|
||||
kernel.vfs.close(handle)
|
||||
end
|
||||
|
||||
local pepper = getFile("/etc/pam.d/secret")
|
||||
|
||||
local function genSalt()
|
||||
return toHex(math.random(0,2^32))
|
||||
end
|
||||
|
||||
local function hashPassword(password, salt)
|
||||
local key = (pepper .. salt)
|
||||
return blake2s(password, key)
|
||||
end
|
||||
|
||||
local passwdFile = getFile("/etc/passwd")
|
||||
local shadowFile = getFile("/etc/shadow")
|
||||
|
||||
local passwdLines = string.split(passwdFile, "\n")
|
||||
local shadowLines = string.split(shadowFile, "\n")
|
||||
|
||||
local passwd, shadow = {}, {}
|
||||
for _, v in ipairs(passwdLines) do
|
||||
local fields = string.split(v, ":")
|
||||
if fields[1] and fields[1] ~= "" then
|
||||
passwd[#passwd + 1] = fields
|
||||
end
|
||||
end
|
||||
for _, v in ipairs(shadowLines) do
|
||||
local fields = string.split(v, ":")
|
||||
if fields[1] and fields[1] ~= "" then
|
||||
shadow[#shadow + 1] = fields
|
||||
end
|
||||
end
|
||||
|
||||
for _, v in ipairs(passwd) do
|
||||
local uid = tonumber(v[1])
|
||||
if uid then kernel.users[uid] = v[3] end
|
||||
end
|
||||
|
||||
kernel.passwd = passwd
|
||||
|
||||
local function flushPasswd()
|
||||
local lines = {}
|
||||
for _, v in ipairs(passwd) do
|
||||
lines[#lines + 1] = table.concat(v, ":")
|
||||
end
|
||||
writeFile("/etc/passwd", table.concat(lines, "\n"))
|
||||
end
|
||||
|
||||
local function flushShadow()
|
||||
local lines = {}
|
||||
for _, v in ipairs(shadow) do
|
||||
lines[#lines + 1] = table.concat(v, ":")
|
||||
end
|
||||
writeFile("/etc/shadow", table.concat(lines, "\n"))
|
||||
end
|
||||
|
||||
local function getPasswdByUID(uid)
|
||||
for _, v in ipairs(passwd) do
|
||||
if tonumber(v[1]) == uid then return v end
|
||||
end
|
||||
return nil
|
||||
end
|
||||
|
||||
local function getShadowByUID(uid)
|
||||
for _, v in ipairs(shadow) do
|
||||
if tonumber(v[1]) == uid then return v end
|
||||
end
|
||||
return nil
|
||||
end
|
||||
|
||||
local function getPasswdByUsername(username)
|
||||
for _, v in ipairs(passwd) do
|
||||
if v[3] == username then return v end
|
||||
end
|
||||
return nil
|
||||
end
|
||||
|
||||
local function nextUID()
|
||||
local max = 999
|
||||
for _, v in ipairs(passwd) do
|
||||
local uid = tonumber(v[1])
|
||||
if uid and uid >= 1000 and uid > max then max = uid end
|
||||
end
|
||||
return max + 1
|
||||
end
|
||||
|
||||
function auth.login(uid, password)
|
||||
if type(uid) ~= "number" or type(password) ~= "string" then
|
||||
return nil, "Authentication failure"
|
||||
end
|
||||
|
||||
local entry = getPasswdByUID(uid)
|
||||
if not entry then
|
||||
-- timing attack resistance
|
||||
hashPassword(password, "aaaaaaaaaaaaaaaa")
|
||||
return nil, "Authentication failure"
|
||||
end
|
||||
|
||||
local sEntry = getShadowByUID(uid)
|
||||
if not sEntry then
|
||||
hashPassword(password, "aaaaaaaaaaaaaaaa")
|
||||
return nil, "Authentication failure"
|
||||
end
|
||||
|
||||
local salt = sEntry[2]
|
||||
local storedHash = sEntry[3]
|
||||
|
||||
local computed = hashPassword(password, salt)
|
||||
if computed ~= storedHash then
|
||||
return nil, "Authentication failure"
|
||||
end
|
||||
|
||||
kernel.currentUID = uid
|
||||
|
||||
local _task = kernel.currentTask
|
||||
if _task then
|
||||
_task.uid = uid
|
||||
_task.euid = uid
|
||||
_task.gid = tonumber(entry[2]) or uid
|
||||
_task.egid = tonumber(entry[2]) or uid
|
||||
end
|
||||
|
||||
kernel.log("AUTH: login uid=" .. tostring(uid) .. " (" .. getPasswdByUID(uid)[3] .. ")")
|
||||
return true
|
||||
end
|
||||
|
||||
function auth.setPassword(uid, newPassword)
|
||||
uid = tonumber(uid)
|
||||
if not uid then return nil, "Invalid uid" end
|
||||
|
||||
local callerUID = (kernel.currentProcess and kernel.currentProcess.euid)
|
||||
or kernel.currentUID or 0
|
||||
|
||||
if callerUID ~= 0 and callerUID ~= uid then
|
||||
return nil, "Permission denied"
|
||||
end
|
||||
|
||||
if type(newPassword) ~= "string" or #newPassword == 0 then
|
||||
return nil, "Password may not be empty"
|
||||
end
|
||||
|
||||
if #newPassword < 6 then
|
||||
return nil, "Password is too short (minimum 6 characters)"
|
||||
end
|
||||
|
||||
local salt = genSalt()
|
||||
local hash = hashPassword(newPassword, salt)
|
||||
|
||||
local sEntry = getShadowByUID(uid)
|
||||
if sEntry then
|
||||
sEntry[2] = salt
|
||||
sEntry[3] = hash
|
||||
else
|
||||
shadow[#shadow + 1] = { tostring(uid), salt, hash }
|
||||
end
|
||||
|
||||
flushShadow()
|
||||
kernel.log("AUTH: password changed for uid=" .. tostring(uid))
|
||||
return true
|
||||
end
|
||||
|
||||
function auth.setUsername(uid, newUsername)
|
||||
uid = tonumber(uid)
|
||||
if not uid then return nil, "Invalid uid" end
|
||||
|
||||
local callerUID = (kernel.currentProcess and kernel.currentProcess.euid)
|
||||
or kernel.currentUID or 0
|
||||
|
||||
if callerUID ~= 0 then
|
||||
return nil, "Permission denied (root only)"
|
||||
end
|
||||
|
||||
if type(newUsername) ~= "string" or #newUsername == 0 then
|
||||
return nil, "Invalid username"
|
||||
end
|
||||
|
||||
if not newUsername:match("^[a-z_][a-z0-9_%-]*$") or #newUsername > 32 then
|
||||
return nil, "Invalid username format"
|
||||
end
|
||||
|
||||
if getPasswdByUsername(newUsername) then
|
||||
return nil, "Username already taken"
|
||||
end
|
||||
|
||||
local entry = getPasswdByUID(uid)
|
||||
if not entry then return nil, "No such user" end
|
||||
|
||||
local oldName = entry[3]
|
||||
entry[3] = newUsername
|
||||
kernel.users[uid] = newUsername
|
||||
|
||||
flushPasswd()
|
||||
kernel.log("AUTH: uid=" .. tostring(uid) .. " renamed '" .. oldName .. "' → '" .. newUsername .. "'")
|
||||
return true
|
||||
end
|
||||
|
||||
function auth.newUser(username, password, gid, homedir, shell)
|
||||
local callerUID = (kernel.currentProcess and kernel.currentProcess.euid)
|
||||
or kernel.currentUID or 0
|
||||
|
||||
if callerUID ~= 0 then
|
||||
return nil, "Permission denied (root only)"
|
||||
end
|
||||
|
||||
if type(username) ~= "string" or #username == 0 then
|
||||
return nil, "Invalid username"
|
||||
end
|
||||
|
||||
if not username:match("^[a-z_][a-z0-9_%-]*$") or #username > 32 then
|
||||
return nil, "Invalid username format"
|
||||
end
|
||||
|
||||
if getPasswdByUsername(username) then
|
||||
return nil, "Username already exists"
|
||||
end
|
||||
|
||||
if type(password) ~= "string" or #password < 6 then
|
||||
return nil, "Password is too short (minimum 6 characters)"
|
||||
end
|
||||
|
||||
local uid = nextUID()
|
||||
gid = tonumber(gid) or uid
|
||||
homedir = homedir or ("/home/" .. username)
|
||||
shell = shell or "/bin/hysh"
|
||||
|
||||
passwd[#passwd + 1] = {
|
||||
tostring(uid),
|
||||
tostring(gid),
|
||||
username,
|
||||
homedir,
|
||||
shell
|
||||
}
|
||||
kernel.users[uid] = username
|
||||
|
||||
local salt = genSalt()
|
||||
local hash = hashPassword(password, salt)
|
||||
shadow[#shadow + 1] = { tostring(uid), salt, hash }
|
||||
|
||||
flushPasswd()
|
||||
flushShadow()
|
||||
|
||||
if kernel.vfs.mkdir and not kernel.vfs.exists(homedir) then
|
||||
kernel.vfs.mkdir(homedir)
|
||||
-- Homedir must be owned by the new user, not root
|
||||
pcall(kernel.vfs.chown, homedir, uid, uid)
|
||||
end
|
||||
|
||||
kernel.log("AUTH: new user '" .. username .. "' uid=" .. tostring(uid))
|
||||
return uid
|
||||
end
|
||||
|
||||
function auth.whoami()
|
||||
local uid = (kernel.currentProcess and kernel.currentProcess.euid)
|
||||
or kernel.currentUID
|
||||
if not uid then return nil, "Not logged in" end
|
||||
return kernel.users[uid] or ("uid=" .. tostring(uid))
|
||||
end
|
||||
|
||||
function auth.getUID(username)
|
||||
local entry = getPasswdByUsername(username)
|
||||
if entry then return tonumber(entry[1]) end
|
||||
return nil
|
||||
end
|
||||
|
||||
function auth.getPasswd(uid)
|
||||
uid = tonumber(uid)
|
||||
local entry = getPasswdByUID(uid)
|
||||
if not entry then return nil end
|
||||
return {
|
||||
uid = tonumber(entry[1]),
|
||||
gid = tonumber(entry[2]),
|
||||
username = entry[3],
|
||||
homedir = entry[4],
|
||||
shell = entry[5],
|
||||
}
|
||||
end
|
||||
|
||||
function auth.deleteUser(uid)
|
||||
uid = tonumber(uid)
|
||||
if not uid then return nil, "Invalid uid" end
|
||||
|
||||
local callerUID = kernel.uid or 0
|
||||
if callerUID ~= 0 then return nil, "Permission denied (root only)" end
|
||||
if uid == 0 then return nil, "Cannot delete root" end
|
||||
|
||||
local entry = getPasswdByUID(uid)
|
||||
if not entry then return nil, "No such user" end
|
||||
local username = entry[3]
|
||||
|
||||
for i, v in ipairs(passwd) do
|
||||
if tonumber(v[1]) == uid then table.remove(passwd, i); break end
|
||||
end
|
||||
for i, v in ipairs(shadow) do
|
||||
if tonumber(v[1]) == uid then table.remove(shadow, i); break end
|
||||
end
|
||||
kernel.users[uid] = nil
|
||||
|
||||
flushPasswd()
|
||||
flushShadow()
|
||||
kernel.log("AUTH: deleted user '" .. username .. "' uid=" .. tostring(uid))
|
||||
return true
|
||||
end
|
||||
|
||||
function auth.lockUser(uid)
|
||||
uid = tonumber(uid)
|
||||
if not uid then return nil, "Invalid uid" end
|
||||
|
||||
local callerUID = kernel.uid or 0
|
||||
if callerUID ~= 0 then return nil, "Permission denied (root only)" end
|
||||
if uid == 0 then return nil, "Cannot lock root" end
|
||||
|
||||
local sEntry = getShadowByUID(uid)
|
||||
if not sEntry then return nil, "No shadow entry for uid" end
|
||||
|
||||
if sEntry[3]:sub(1,1) ~= "!" then
|
||||
sEntry[3] = "!" .. sEntry[3]
|
||||
end
|
||||
flushShadow()
|
||||
kernel.log("AUTH: locked uid=" .. tostring(uid))
|
||||
return true
|
||||
end
|
||||
|
||||
function auth.unlockUser(uid)
|
||||
uid = tonumber(uid)
|
||||
if not uid then return nil, "Invalid uid" end
|
||||
|
||||
local callerUID = kernel.uid or 0
|
||||
if callerUID ~= 0 then return nil, "Permission denied (root only)" end
|
||||
|
||||
local sEntry = getShadowByUID(uid)
|
||||
if not sEntry then return nil, "No shadow entry for uid" end
|
||||
|
||||
if sEntry[3]:sub(1,1) == "!" then
|
||||
sEntry[3] = sEntry[3]:sub(2)
|
||||
end
|
||||
flushShadow()
|
||||
kernel.log("AUTH: unlocked uid=" .. tostring(uid))
|
||||
return true
|
||||
end
|
||||
|
||||
function auth.listUsers()
|
||||
local result = {}
|
||||
for _, v in ipairs(passwd) do
|
||||
local uid = tonumber(v[1])
|
||||
local sEntry = getShadowByUID(uid)
|
||||
local locked = sEntry and sEntry[3]:sub(1,1) == "!"
|
||||
result[#result+1] = {
|
||||
uid = uid,
|
||||
gid = tonumber(v[2]),
|
||||
username = v[3],
|
||||
homedir = v[4],
|
||||
shell = v[5],
|
||||
locked = locked or false,
|
||||
}
|
||||
end
|
||||
return result
|
||||
end
|
||||
|
||||
function auth.setShell(uid, shell)
|
||||
uid = tonumber(uid)
|
||||
if not uid then return nil, "Invalid uid" end
|
||||
|
||||
local callerUID = kernel.uid or 0
|
||||
if callerUID ~= 0 and callerUID ~= uid then
|
||||
return nil, "Permission denied"
|
||||
end
|
||||
|
||||
if type(shell) ~= "string" or #shell == 0 then
|
||||
return nil, "Invalid shell"
|
||||
end
|
||||
|
||||
local entry = getPasswdByUID(uid)
|
||||
if not entry then return nil, "No such user" end
|
||||
entry[5] = shell
|
||||
|
||||
flushPasswd()
|
||||
kernel.log("AUTH: uid=" .. tostring(uid) .. " shell -> " .. shell)
|
||||
return true
|
||||
end
|
||||
|
||||
function auth.setHomedir(uid, homedir)
|
||||
uid = tonumber(uid)
|
||||
if not uid then return nil, "Invalid uid" end
|
||||
|
||||
local callerUID = kernel.uid or 0
|
||||
if callerUID ~= 0 then return nil, "Permission denied (root only)" end
|
||||
|
||||
if type(homedir) ~= "string" or #homedir == 0 then
|
||||
return nil, "Invalid homedir"
|
||||
end
|
||||
|
||||
local entry = getPasswdByUID(uid)
|
||||
if not entry then return nil, "No such user" end
|
||||
entry[4] = homedir
|
||||
|
||||
flushPasswd()
|
||||
kernel.log("AUTH: uid=" .. tostring(uid) .. " homedir -> " .. homedir)
|
||||
return true
|
||||
end
|
||||
|
||||
function auth.setGID(uid, gid)
|
||||
uid = tonumber(uid)
|
||||
gid = tonumber(gid)
|
||||
if not uid or not gid then return nil, "Invalid uid or gid" end
|
||||
|
||||
local callerUID = kernel.uid or 0
|
||||
if callerUID ~= 0 then return nil, "Permission denied (root only)" end
|
||||
|
||||
local entry = getPasswdByUID(uid)
|
||||
if not entry then return nil, "No such user" end
|
||||
entry[2] = tostring(gid)
|
||||
|
||||
flushPasswd()
|
||||
kernel.log("AUTH: uid=" .. tostring(uid) .. " gid -> " .. tostring(gid))
|
||||
return true
|
||||
end
|
||||
|
||||
function auth.elevate(targetUsername, password)
|
||||
if type(targetUsername) ~= "string" or type(password) ~= "string" then
|
||||
return nil, "Authentication failure"
|
||||
end
|
||||
|
||||
local entry = getPasswdByUsername(targetUsername)
|
||||
if not entry then
|
||||
hashPassword(password, "aaaaaaaaaaaaaaaa") -- timing resistance
|
||||
return nil, "Authentication failure"
|
||||
end
|
||||
|
||||
local uid = tonumber(entry[1])
|
||||
local sEntry = getShadowByUID(uid)
|
||||
if not sEntry then
|
||||
hashPassword(password, "aaaaaaaaaaaaaaaa")
|
||||
return nil, "Authentication failure"
|
||||
end
|
||||
|
||||
local computed = hashPassword(password, sEntry[2])
|
||||
if computed ~= sEntry[3] then
|
||||
return nil, "Authentication failure"
|
||||
end
|
||||
|
||||
local task = kernel.currentTask
|
||||
local prevUid = task.uid
|
||||
task.uid = 0
|
||||
task.euid = 0
|
||||
task.gid = 0
|
||||
task.egid = 0
|
||||
kernel.uid = 0
|
||||
|
||||
kernel.log("AUTH: elevate uid=" .. tostring(prevUid) .. " -> 0 (via " .. targetUsername .. ")")
|
||||
return true, uid
|
||||
end
|
||||
|
||||
if kernel.syscalls then
|
||||
kernel.syscalls["login"] = auth.login
|
||||
kernel.syscalls["setpassword"] = auth.setPassword
|
||||
kernel.syscalls["setusername"] = auth.setUsername
|
||||
kernel.syscalls["newuser"] = auth.newUser
|
||||
kernel.syscalls["whoami"] = auth.whoami
|
||||
kernel.syscalls["getuidbyname"]= auth.getUID
|
||||
kernel.syscalls["getpasswd"] = auth.getPasswd
|
||||
kernel.syscalls["elevate"] = auth.elevate
|
||||
kernel.syscalls["deleteuser"] = auth.deleteUser
|
||||
kernel.syscalls["lockuser"] = auth.lockUser
|
||||
kernel.syscalls["unlockuser"] = auth.unlockUser
|
||||
kernel.syscalls["listusers"] = auth.listUsers
|
||||
kernel.syscalls["setshell"] = auth.setShell
|
||||
kernel.syscalls["sethomedir"] = auth.setHomedir
|
||||
kernel.syscalls["setgid"] = auth.setGID
|
||||
end
|
||||
@@ -0,0 +1,520 @@
|
||||
--:Minify:--
|
||||
local kernel = ...
|
||||
local tasks = {}
|
||||
local sys = {}
|
||||
local nextpid = 2
|
||||
kernel.exitMain = false
|
||||
|
||||
local resumeWithTimeout = coroutine.resumeWithTimeout
|
||||
|
||||
local function bit_is_set(num, bit)
|
||||
return math.floor(num / (2 ^ bit)) % 2 == 1
|
||||
end
|
||||
|
||||
local function loadExecutable(path)
|
||||
kernel.vfs.access(path, "rx")
|
||||
|
||||
local fd = kernel.vfs.open(path, "r")
|
||||
local data = kernel.vfs.read(fd, 1024 * 1024 * 4)
|
||||
kernel.vfs.close(fd)
|
||||
|
||||
local env = kernel.freshUserEnv()
|
||||
|
||||
local func, err = load(data, "@" .. path, "t", env)
|
||||
if not func then error("ENOEXEC: " .. tostring(err)) end
|
||||
|
||||
local meta = kernel.vfs.lstat(path)
|
||||
local suid_set = bit_is_set(meta.perms, 6)
|
||||
local caller_uid = kernel.currentTask and kernel.currentTask.uid or kernel.uid
|
||||
local euid = suid_set and meta.owner or caller_uid
|
||||
|
||||
return func, euid, suid_set
|
||||
end
|
||||
|
||||
local function createTask(func, name, envars, args, tgid, real_uid, eff_uid)
|
||||
local id = nextpid
|
||||
nextpid = nextpid + 1
|
||||
|
||||
tasks[tostring(id)] = {
|
||||
coro = coroutine.create(function()
|
||||
local ok, err = xpcall(func, debug.traceback, table.unpack(args or {}))
|
||||
|
||||
if kernel.config.logTaskExit then
|
||||
if not ok then
|
||||
kernel.log("Task " .. tostring(id) .. " exited with err: " .. tostring(err), "ERROR", 0xFF0000)
|
||||
elseif err then
|
||||
kernel.log("Task " .. tostring(id) .. " exited with code: " .. tostring(err), "DBUG", 0x00FFFF)
|
||||
else
|
||||
kernel.log("Task " .. tostring(id) .. " exited without code", "DBUG", 0x00FFFF)
|
||||
end
|
||||
end
|
||||
|
||||
if type(err) == "number" then
|
||||
tasks[tostring(id)].exit = err
|
||||
end
|
||||
|
||||
if tasks[tostring(id)].fd then
|
||||
for fd, _ in pairs(tasks[tostring(id)].fd) do
|
||||
pcall(kernel.vfs.close, fd)
|
||||
end
|
||||
end
|
||||
tasks[tostring(id)].status = "Z"
|
||||
end),
|
||||
|
||||
name = name or ("task" .. tostring(id)),
|
||||
envars = envars or (kernel.currentTask and kernel.currentTask.envars or {}),
|
||||
args = args or {},
|
||||
status = "R",
|
||||
pid = id,
|
||||
tgid = tgid or (kernel.currentTask and kernel.currentTask.tgid or id),
|
||||
uid = real_uid,
|
||||
euid = eff_uid,
|
||||
gid = (kernel.currentTask and kernel.currentTask.gid) or 0,
|
||||
groups = (kernel.currentTask and kernel.currentTask.groups) or {},
|
||||
fd = {},
|
||||
sleep = 0,
|
||||
ivs = 0,
|
||||
vs = 0,
|
||||
children = {},
|
||||
parent = kernel.currentTask or kernel.kernelTask,
|
||||
siblings = (kernel.currentTask and kernel.currentTask.children) or kernel.kernelTask.children,
|
||||
syscallReturn = {},
|
||||
cwd = (kernel.currentTask and kernel.currentTask.cwd) or "/",
|
||||
timeSlice = 0,
|
||||
lastTime = 0,
|
||||
totalTime = 0,
|
||||
numRuns = 0,
|
||||
}
|
||||
|
||||
table.insert(
|
||||
(kernel.currentTask and kernel.currentTask.children) or kernel.kernelTask.children,
|
||||
tasks[tostring(id)]
|
||||
)
|
||||
return id
|
||||
end
|
||||
|
||||
function sys.spawn(func, name, envars, args, tgid)
|
||||
local caller = kernel.currentTask
|
||||
local real_uid = caller and caller.uid or kernel.uid
|
||||
local eff_uid = caller and caller.euid or real_uid
|
||||
return createTask(func, name, envars, args, tgid, real_uid, eff_uid)
|
||||
end
|
||||
|
||||
function sys.execspawn(path, name, envars, args, tgid)
|
||||
local func, euid, suid_active = loadExecutable(path, kernel._U)
|
||||
|
||||
local caller = kernel.currentTask
|
||||
local real_uid = caller and caller.uid or kernel.uid
|
||||
|
||||
if suid_active then
|
||||
kernel.log(
|
||||
"execspawn: suid exec '" .. path ..
|
||||
"' caller_uid=" .. tostring(real_uid) ..
|
||||
" -> euid=" .. tostring(euid)
|
||||
)
|
||||
end
|
||||
|
||||
return createTask(func, name or path, envars, args, tgid, real_uid, euid)
|
||||
end
|
||||
|
||||
function sys.exec(path, args, envars)
|
||||
local task = kernel.currentTask
|
||||
local func, euid, _ = loadExecutable(path, kernel._U)
|
||||
|
||||
if task.fd then
|
||||
for fd, _ in pairs(task.fd) do
|
||||
if fd > 2 then pcall(kernel.vfs.close, fd) end
|
||||
end
|
||||
end
|
||||
|
||||
task.euid = euid
|
||||
task.args = args or {}
|
||||
task.envars = envars or task.envars
|
||||
task.name = path
|
||||
|
||||
task.coro = coroutine.create(function()
|
||||
local ok, err = xpcall(func, debug.traceback, table.unpack(task.args))
|
||||
if kernel.config.logTaskExit then
|
||||
if not ok then
|
||||
kernel.log("Task " .. tostring(task.pid) .. " exec '" .. path .. "' err: " .. tostring(err), "ERROR", 0xFF0000)
|
||||
else
|
||||
kernel.log("Task " .. tostring(task.pid) .. " exec '" .. path .. "' exited: " .. tostring(err), "DBUG", 0x00FFFF)
|
||||
end
|
||||
end
|
||||
if type(err) == "number" then tasks[tostring(task.pid)].exit = err end
|
||||
if tasks[tostring(task.pid)].fd then
|
||||
for fd, _ in pairs(tasks[tostring(task.pid)].fd) do
|
||||
pcall(kernel.vfs.close, fd)
|
||||
end
|
||||
end
|
||||
tasks[tostring(task.pid)].status = "Z"
|
||||
end)
|
||||
task.syscallReturn = {}
|
||||
coroutine.yield()
|
||||
end
|
||||
|
||||
function sys.sleep(s)
|
||||
kernel.currentTask.status = "S"
|
||||
kernel.currentTask.sleep = kernel.EFI:getEpochMs() + s * 1000
|
||||
end
|
||||
|
||||
function sys.getTask(pid)
|
||||
local task = tasks[tostring(pid)]
|
||||
if not task then return nil end
|
||||
|
||||
local children, siblings = {}, {}
|
||||
for i, v in ipairs(task.children) do children[i] = v.pid end
|
||||
for i, v in ipairs(task.siblings) do siblings[i] = v.pid end
|
||||
|
||||
return {
|
||||
name = task.name,
|
||||
status = task.status,
|
||||
pid = task.pid,
|
||||
tgid = task.tgid,
|
||||
username = kernel.users[task.uid],
|
||||
uid = task.uid,
|
||||
euid = task.euid,
|
||||
exit = task.exit,
|
||||
sleep = task.sleep,
|
||||
ivs = task.ivs,
|
||||
vs = task.vs,
|
||||
children = children,
|
||||
siblings = siblings,
|
||||
parent = task.parent.pid,
|
||||
cwd = task.cwd,
|
||||
term = task.term,
|
||||
}
|
||||
end
|
||||
|
||||
function sys.collect(pid)
|
||||
local children = {}
|
||||
for _, v in ipairs(kernel.currentTask.children) do children[#children+1] = v.pid end
|
||||
|
||||
local task = tasks[tostring(pid)]
|
||||
if not task then
|
||||
return false, "Task does not exist"
|
||||
elseif not isEqualToAny(task.pid, table.unpack(children)) then
|
||||
return false, "You do not own this task"
|
||||
elseif task.status ~= "Z" then
|
||||
return false, "Task must exit to collect status"
|
||||
else
|
||||
task.reapTime = 0
|
||||
return true, task.exit
|
||||
end
|
||||
end
|
||||
|
||||
function sys.kill(pid, force)
|
||||
local task = tasks[tostring(pid)]
|
||||
if not task then
|
||||
return false, "Task does not exist"
|
||||
elseif task.status == "Z" then
|
||||
return false, "Task is already dead"
|
||||
elseif task.status == "D" and not force then
|
||||
return false, "Cannot kill task waiting for IO"
|
||||
end
|
||||
local caller = kernel.currentTask
|
||||
local ceuid = caller and (caller.euid or caller.uid) or kernel.uid
|
||||
if ceuid ~= 0 and task.uid ~= (caller and caller.uid or kernel.uid) then
|
||||
return false, "EPERM"
|
||||
end
|
||||
task.status = "Z"
|
||||
return true
|
||||
end
|
||||
|
||||
function sys.stop(pid)
|
||||
local task = tasks[tostring(pid)]
|
||||
if not task then
|
||||
return false, "Task does not exist"
|
||||
elseif task.status ~= "R" and task.status ~= "S" then
|
||||
return false, "Cannot stop non-running task"
|
||||
else
|
||||
if task.status == "S" then
|
||||
task.status = "ST"
|
||||
else
|
||||
task.status = "T"
|
||||
end
|
||||
return true
|
||||
end
|
||||
end
|
||||
|
||||
function sys.continue(pid)
|
||||
local task = tasks[tostring(pid)]
|
||||
if not task then
|
||||
return false, "Task does not exist"
|
||||
elseif task.status ~= "T" and task.status ~= "ST" then
|
||||
return false, "Task is not stopped"
|
||||
else
|
||||
if task.status == "ST" then
|
||||
task.status = "S"
|
||||
else
|
||||
task.status = "R"
|
||||
end
|
||||
return true
|
||||
end
|
||||
end
|
||||
|
||||
function sys.getpid() return kernel.currentTask.pid end
|
||||
function sys.getppid() return kernel.currentTask.parent.pid end
|
||||
|
||||
function sys.getTasks()
|
||||
local ret = {}
|
||||
for _, v in pairs(tasks) do ret[#ret+1] = v.pid end
|
||||
return ret
|
||||
end
|
||||
|
||||
function sys.getEnviron(key) return kernel.currentTask.envars[key] end
|
||||
function sys.setEnviron(key, val) kernel.currentTask.envars[key] = val end
|
||||
|
||||
function sys.exit(code)
|
||||
local task = kernel.currentTask
|
||||
if kernel.config.logTaskExit then
|
||||
if code then
|
||||
kernel.log("Task " .. tostring(task.pid) .. " exited with code: " .. tostring(code), "DBUG", 0x00FFFF)
|
||||
else
|
||||
kernel.log("Task " .. tostring(task.pid) .. " exited without code", "DBUG", 0x00FFFF)
|
||||
end
|
||||
end
|
||||
tasks[tostring(task.pid)].status = "Z"
|
||||
if type(code) == "number" then
|
||||
tasks[tostring(task.pid)].exit = code
|
||||
end
|
||||
end
|
||||
|
||||
function sys.setuid(uid)
|
||||
local task = kernel.currentTask
|
||||
if task.euid ~= 0 and task.uid ~= uid then
|
||||
error("EPERM")
|
||||
end
|
||||
task.uid = uid
|
||||
task.euid = uid
|
||||
kernel.uid = uid
|
||||
end
|
||||
|
||||
function sys.geteuid()
|
||||
return kernel.currentTask.euid
|
||||
end
|
||||
|
||||
function sys.getuid() return kernel.currentTask.uid end
|
||||
|
||||
local function reapDeadTasks()
|
||||
for pid, task in pairs(tasks) do
|
||||
if task.status == "Z" and not task.reapTime then
|
||||
task.coro = nil
|
||||
task.ivs = nil
|
||||
task.vs = nil
|
||||
task.args = nil
|
||||
task.envars = nil
|
||||
task.cwd = nil
|
||||
task.numRuns = nil
|
||||
task.totalTime = nil
|
||||
task.lastTime = nil
|
||||
task.timeSlice = nil
|
||||
task.syscallReturn = nil
|
||||
task.sleep = nil
|
||||
task.fd = nil
|
||||
task.reapTime = kernel.EFI:getEpochMs() + 30000
|
||||
|
||||
elseif task.reapTime and kernel.EFI:getEpochMs() > task.reapTime
|
||||
and task.status == "Z" then
|
||||
for _, child in ipairs(task.children) do
|
||||
child.parent = tasks["1"]
|
||||
child.siblings = tasks["1"].children
|
||||
table.insert(tasks["1"].children, child)
|
||||
end
|
||||
for i, sibling in ipairs(task.siblings) do
|
||||
if sibling.pid == task.pid then
|
||||
table.remove(task.siblings, i)
|
||||
break
|
||||
end
|
||||
end
|
||||
tasks[pid] = nil
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
local alpha = 0.85
|
||||
local C_target = 0.01
|
||||
local Tmin = 0.0005
|
||||
local Tmax = 0.5
|
||||
local lambda_budget = 0.08
|
||||
local lambda_clamp = 0.03
|
||||
local lambda_var = 0.02
|
||||
local k_min = 0.5
|
||||
local k_max = 0.5
|
||||
local B = 0.01
|
||||
|
||||
function kernel.main()
|
||||
while not kernel.exitMain do
|
||||
local N = 0
|
||||
local Tmin_hit = 0
|
||||
local Tmax_hit = 0
|
||||
local totalTaskTime = 0
|
||||
local taskTimes = {}
|
||||
|
||||
for pid, task in pairs(tasks) do
|
||||
kernel.currentTask = task
|
||||
kernel.uid = task.euid or task.uid
|
||||
kernel.process = task.name
|
||||
|
||||
if task.status == "S" and kernel.EFI:getEpochMs() >= task.sleep then
|
||||
task.status = "R"
|
||||
task.sleep = 0
|
||||
end
|
||||
|
||||
if task.status == "ST" and kernel.EFI:getEpochMs() >= task.sleep then
|
||||
task.status = "T"
|
||||
task.sleep = 0
|
||||
end
|
||||
|
||||
if task.status == "D" then
|
||||
if task.ksh then
|
||||
coroutine.resume(task.ksh)
|
||||
end
|
||||
end
|
||||
|
||||
if task.status == "R" then
|
||||
N = N + 1
|
||||
|
||||
task.timeSlice = math.min(Tmax, math.max(Tmin, B / (N ^ alpha)))
|
||||
|
||||
if task.sigq and #task.sigq ~= 0 and task.sigh then
|
||||
local coro = coroutine.create(task.sigh)
|
||||
local status,err
|
||||
if kernel.config.preempt then
|
||||
status,err=coroutine.resumeWithTimeout(coro, 100, table.remove(task.sigq, 1))
|
||||
else
|
||||
status,err=coroutine.resume(coro, table.remove(task.sigq, 1))
|
||||
end
|
||||
if status=="error" or status==false then
|
||||
task.sigd.error=err or "Unknown"
|
||||
task.sigd.active=false
|
||||
task.sigh=nil
|
||||
task.sigq=nil
|
||||
task.sigd=nil
|
||||
elseif status=="success" or status==true then
|
||||
if err=="syscall" then
|
||||
task.sigd.error="Cannot execute syscalls from signals"
|
||||
task.sigd.active=false
|
||||
task.sigh=nil
|
||||
task.sigq=nil
|
||||
task.sigd=nil
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
if task.status == "R" then
|
||||
local startTime = kernel.EFI:getEpochMs()
|
||||
local ret
|
||||
|
||||
if kernel.config.preempt then
|
||||
if not task.debugger then
|
||||
ret = { resumeWithTimeout(task.coro, task.timeSlice, table.unpack(task.syscallReturn)) }
|
||||
else
|
||||
ret = { coroutine.resume(task.coro, table.unpack(task.syscallReturn)) }
|
||||
end
|
||||
else
|
||||
ret = { coroutine.resume(task.coro, table.unpack(task.syscallReturn)) }
|
||||
end
|
||||
|
||||
local elapsed = kernel.EFI:getEpochMs() - startTime
|
||||
task.lastTime = elapsed
|
||||
task.totalTime = (task.totalTime or 0) + elapsed
|
||||
task.numRuns = (task.numRuns or 0) + 1
|
||||
|
||||
taskTimes[#taskTimes+1] = elapsed
|
||||
totalTaskTime = totalTaskTime + elapsed
|
||||
|
||||
if elapsed <= Tmin then Tmin_hit = Tmin_hit + 1 end
|
||||
if elapsed >= Tmax then Tmax_hit = Tmax_hit + 1 end
|
||||
|
||||
if ret[1] == "error" or ret[1] == false then
|
||||
kernel.log("processHandlerException: " .. tostring(ret[2]), "ERROR", 0xFF0000)
|
||||
task.status = "Z"
|
||||
task.exit = "processHandlerException: " .. tostring(ret[2])
|
||||
|
||||
elseif ret[1] == "timeout" then
|
||||
task.ivs = task.ivs + 1
|
||||
task.syscallReturn = {}
|
||||
|
||||
elseif ret[1] == "success" or ret[1] == true then
|
||||
task.vs = task.vs + 1
|
||||
|
||||
if ret[2] == "syscall" then
|
||||
local scname = ret[3]
|
||||
if kernel.syscalls[scname] then
|
||||
if kernel.config.debugSyscalls then
|
||||
kernel.log("Task " .. task.pid .. " syscall: " .. scname, "DBUG", 0x00FFFF)
|
||||
for i = 4, #ret do
|
||||
kernel.log(" inval[" .. (i-3) .. "] = " .. tostring(ret[i]), "DBUG", 0x00FFFF)
|
||||
end
|
||||
end
|
||||
|
||||
local sysret = { xpcall(kernel.syscalls[scname], debug.traceback, table.unpack(ret, 4)) }
|
||||
|
||||
if kernel.config.debugSyscalls then
|
||||
if not sysret[1] then
|
||||
kernel.log("Task " .. task.pid .. " syscall " .. scname .. " failed: " .. tostring(sysret[2]), "ERROR", 0xFF0000)
|
||||
else
|
||||
kernel.log("Task " .. task.pid .. " syscall " .. scname .. " ok, " .. (#sysret-1) .. " retvals", "DBUG", 0x00FFFF)
|
||||
for i = 2, #sysret do
|
||||
local v = type(sysret[i]) == "table" and table.serialize(sysret[i]) or tostring(sysret[i])
|
||||
kernel.log(" retval[" .. (i-1) .. "] = " .. v, "DBUG", 0x00FFFF)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
if not sysret[1] then
|
||||
task.syscallReturn = { false, sysret[2] }
|
||||
else
|
||||
task.syscallReturn = { true, table.unpack(sysret, 2) }
|
||||
end
|
||||
else
|
||||
task.syscallReturn = { false, "Unknown syscall: " .. tostring(scname) }
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
local T_prev_avg = (N > 0) and (totalTaskTime / N) or 0
|
||||
local T_prev_var = 0
|
||||
for _, t in ipairs(taskTimes) do
|
||||
T_prev_var = T_prev_var + (t - T_prev_avg) ^ 2
|
||||
end
|
||||
if N > 0 then T_prev_var = T_prev_var / N end
|
||||
|
||||
if N > 0 then
|
||||
local f_clamp = k_min * (Tmin_hit / N) - k_max * (Tmax_hit / N)
|
||||
local B_budget = (C_target * (N ^ (alpha - 1))) / math.max(T_prev_avg, 1e-8)
|
||||
B = B + lambda_budget * (B_budget - B) + lambda_clamp * f_clamp - lambda_var * T_prev_var
|
||||
end
|
||||
|
||||
reapDeadTasks()
|
||||
end
|
||||
end
|
||||
|
||||
local sysc = kernel.syscalls
|
||||
sysc["spawn"] = sys.spawn
|
||||
sysc["execspawn"] = sys.execspawn
|
||||
sysc["exec"] = sys.exec
|
||||
sysc["sleep"] = sys.sleep
|
||||
sysc["getTask"] = sys.getTask
|
||||
sysc["collect"] = sys.collect
|
||||
sysc["kill"] = sys.kill
|
||||
sysc["stop"] = sys.stop
|
||||
sysc["continue"] = sys.continue
|
||||
sysc["getpid"] = sys.getpid
|
||||
sysc["getppid"] = sys.getppid
|
||||
sysc["getTasks"] = sys.getTasks
|
||||
sysc["setEnviron"] = sys.setEnviron
|
||||
sysc["getEnviron"] = sys.getEnviron
|
||||
sysc["exit"] = sys.exit
|
||||
sysc["setuid"] = sys.setuid
|
||||
sysc["getuid"] = sys.getuid
|
||||
sysc["geteuid"] = sys.geteuid
|
||||
|
||||
kernel._G.sleep = function(...) coroutine.yield("syscall", "sleep", ...) end
|
||||
|
||||
kernel.tasks = tasks
|
||||
kernel.hpv = sys
|
||||
@@ -0,0 +1,7 @@
|
||||
--:Minify:--
|
||||
local kernel=...
|
||||
local debug=debug
|
||||
kernel._G.debug={
|
||||
getinfo=debug.getinfo,
|
||||
traceback=debug.traceback
|
||||
}
|
||||
@@ -0,0 +1,28 @@
|
||||
--:Minify:--
|
||||
local kernel=...
|
||||
local sysc=kernel.syscalls
|
||||
kernel.gpio={}
|
||||
|
||||
sysc["gpio_write"]=function(pin, data)
|
||||
if kernel.gpio[pin] then
|
||||
return kernel.gpio[pin]("w", data)
|
||||
end
|
||||
end
|
||||
|
||||
sysc["gpio_writeAnalog"]=function(pin, data)
|
||||
if kernel.gpio[pin] then
|
||||
return kernel.gpio[pin]("wa", data)
|
||||
end
|
||||
end
|
||||
|
||||
sysc["gpio_read"]=function(pin)
|
||||
if kernel.gpio[pin] then
|
||||
return kernel.gpio[pin]("r")
|
||||
end
|
||||
end
|
||||
|
||||
sysc["gpio_readAnalog"]=function(pin)
|
||||
if kernel.gpio[pin] then
|
||||
return kernel.gpio[pin]("ra")
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,22 @@
|
||||
--:Minify:--
|
||||
local kernel = ...
|
||||
function print(...)
|
||||
local args = {...}
|
||||
local output = ""
|
||||
for i = 1, #args do output = output .. tostring(args[i]) .. "\t" end
|
||||
output = output:sub(1, -2)
|
||||
syscall.write(1, output.."\n")
|
||||
end
|
||||
|
||||
function printf(fmt, ...)
|
||||
local output = string.format(fmt, ...)
|
||||
syscall.write(1, output.."\n")
|
||||
end
|
||||
|
||||
function printInline(...)
|
||||
local args = {...}
|
||||
local output = ""
|
||||
for i = 1, #args do output = output .. tostring(args[i]) .. "\t" end
|
||||
output = output:sub(1, -2)
|
||||
syscall.write(1, output)
|
||||
end
|
||||
@@ -0,0 +1,54 @@
|
||||
--:Minify:--
|
||||
local kernel = ...
|
||||
kernel.log("Loading init system...")
|
||||
kernel.log("InitPath: " .. kernel.config.initPath)
|
||||
|
||||
local initOk, initErr = pcall(kernel.vfs.access, kernel.config.initPath, "rx")
|
||||
if not initOk then
|
||||
kernel.PANIC("Init binary not executable: " .. kernel.config.initPath .. " (" .. tostring(initErr) .. ")")
|
||||
end
|
||||
|
||||
local handle = kernel.vfs.open(kernel.config.initPath, "r")
|
||||
if not handle then kernel.panic("Failed to open "..kernel.config.initPath) end
|
||||
local data = kernel.vfs.read(handle, 1024 * 1024 * 4)
|
||||
if not handle then kernel.panic("Failed to read "..kernel.config.initPath) end
|
||||
kernel.vfs.close(handle)
|
||||
|
||||
local initFunc, err = load(data, "@sysinit", "t", kernel._U)
|
||||
if not initFunc then kernel.PANIC("Failed to load init system: " .. err) end
|
||||
|
||||
kernel.tasks["1"] = {
|
||||
coro = coroutine.create(function()
|
||||
local ok, err = xpcall(initFunc, debug.traceback, kernel)
|
||||
if not ok then
|
||||
kernel.panic("Init system crashed: " .. tostring(err))
|
||||
else
|
||||
kernel.panic("Init system exited: " .. tostring(err))
|
||||
end
|
||||
end),
|
||||
|
||||
name = "sysinit",
|
||||
status = "R",
|
||||
pid = 1,
|
||||
tgid = 1,
|
||||
uid = 0,
|
||||
fd = {},
|
||||
envars = {},
|
||||
args = {},
|
||||
exit = "",
|
||||
sleep = 0,
|
||||
ivs = 0,
|
||||
vs = 0,
|
||||
parent = kernel.kernelTask,
|
||||
siblings = kernel.kernelTask.children,
|
||||
children = {},
|
||||
syscallReturn = {},
|
||||
cwd = "/",
|
||||
timeSlice = 0,
|
||||
lastTime = 0,
|
||||
totalTime = 0,
|
||||
numRuns = 0
|
||||
}
|
||||
|
||||
kernel.log("created init task with PID 1")
|
||||
kernel.log("Initializing init system...")
|
||||
@@ -0,0 +1,10 @@
|
||||
--:Minify:--
|
||||
local kernel = ...
|
||||
if not kernel.vfs.exists("/root") then kernel.vfs.mkdir("/root") end
|
||||
|
||||
kernel.processes.login = function()
|
||||
local ok, err = pcall(kernel.hpv.execspawn, "/bin/login", "login")
|
||||
if not ok then
|
||||
kernel.log("Failed to exec /bin/login: " .. tostring(err), "ERROR", 0xFF0000)
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,121 @@
|
||||
--:Minify:--
|
||||
local kernel = ...
|
||||
|
||||
if kernel.firstBoot then
|
||||
local P = kernel.vfs.P
|
||||
local PERM = kernel.vfs.PERM
|
||||
|
||||
local RW_R_R = P.OWNER_R + P.OWNER_W + P.GROUP_R + P.WORLD_R
|
||||
local RWX_RX_RX = P.OWNER_R + P.OWNER_W + P.OWNER_X
|
||||
+ P.GROUP_R + P.GROUP_X
|
||||
+ P.WORLD_R + P.WORLD_X
|
||||
local RW_R__ = P.OWNER_R + P.OWNER_W + P.GROUP_R
|
||||
local RW____ = P.OWNER_R + P.OWNER_W
|
||||
local RWXRWXRWX = PERM.RWXRWXRWX
|
||||
local SUID_755 = PERM.SUID_755
|
||||
|
||||
local META_VERSION = 0x02
|
||||
local rootDisk = kernel.disks["$"]
|
||||
|
||||
local function makeEntry(name, etype, owner, group, perms, cmeta)
|
||||
cmeta = cmeta or ""
|
||||
local plo = perms % 256
|
||||
local phi = math.floor(perms / 256) % 256
|
||||
local olo = (owner or 0) % 256
|
||||
local ohi = math.floor((owner or 0) / 256) % 256
|
||||
local glo = (group or 0) % 256
|
||||
local ghi = math.floor((group or 0) / 256) % 256
|
||||
return string.char(#name) .. name
|
||||
.. string.char(etype, olo, ohi, glo, ghi, plo, phi)
|
||||
.. string.char(#cmeta) .. cmeta
|
||||
end
|
||||
|
||||
local REG = 0x00
|
||||
|
||||
local function mergeMeta(dir, entries)
|
||||
local diskDir = dir
|
||||
if diskDir:sub(1,1) == "/" then diskDir = diskDir:sub(2) end
|
||||
local metaPath = (diskDir == "" and ".meta" or diskDir .. "/.meta")
|
||||
|
||||
local existing = {}
|
||||
local rok, rf = pcall(function() return rootDisk:open(metaPath, "r") end)
|
||||
if rok and rf then
|
||||
local raw = rf.read(65535)
|
||||
if rf.close then rf.close() end
|
||||
existing = (kernel.vfs._parseMetafile and kernel.vfs._parseMetafile(raw)) or {}
|
||||
end
|
||||
|
||||
for _, e in ipairs(entries) do
|
||||
local name = e[1]
|
||||
local etype = e[2] or REG
|
||||
local owner = e[3] or 0
|
||||
local group = e[4] or 0
|
||||
local perms = e[5] or RWX_RX_RX
|
||||
local cmeta = e[6] or ""
|
||||
existing[name] = {
|
||||
etype = etype,
|
||||
owner = owner,
|
||||
group = group,
|
||||
perms = perms,
|
||||
cmeta = cmeta,
|
||||
}
|
||||
end
|
||||
|
||||
local data = string.char(META_VERSION)
|
||||
for name, m in pairs(existing) do
|
||||
data = data .. makeEntry(
|
||||
name,
|
||||
m.etype or REG,
|
||||
m.owner or 0,
|
||||
m.group or 0,
|
||||
m.perms or RWX_RX_RX,
|
||||
m.cmeta or ""
|
||||
)
|
||||
end
|
||||
|
||||
local ok, err = pcall(function()
|
||||
local f = rootDisk:open(metaPath, "w")
|
||||
f.write(data)
|
||||
f.close()
|
||||
end)
|
||||
if not ok then
|
||||
kernel.log("permissions: failed to write " .. metaPath .. ": " .. tostring(err), "WARN", 0xFF8800)
|
||||
end
|
||||
end
|
||||
|
||||
kernel.log("Seeding filesystem permissions...")
|
||||
|
||||
mergeMeta("/", {
|
||||
{"bin", REG, 0, 0, RWX_RX_RX},
|
||||
{"boot", REG, 0, 0, RWX_RX_RX},
|
||||
{"dev", REG, 0, 0, RWXRWXRWX},
|
||||
{"etc", REG, 0, 0, RWX_RX_RX},
|
||||
{"home", REG, 0, 0, RWX_RX_RX},
|
||||
{"lib", REG, 0, 0, RWX_RX_RX},
|
||||
{"proc", REG, 0, 0, RWXRWXRWX},
|
||||
{"root", REG, 0, 0, RW____ },
|
||||
{"sbin", REG, 0, 0, RWX_RX_RX},
|
||||
{"tmp", REG, 0, 0, RWXRWXRWX},
|
||||
{"usr", REG, 0, 0, RWX_RX_RX},
|
||||
{"var", REG, 0, 0, RWXRWXRWX},
|
||||
{"opt", REG, 0, 0, RWX_RX_RX},
|
||||
})
|
||||
|
||||
mergeMeta("/bin", {
|
||||
{"login", REG, 0, 0, SUID_755 },
|
||||
{"su", REG, 0, 0, SUID_755 },
|
||||
{"sudo", REG, 0, 0, SUID_755 },
|
||||
})
|
||||
|
||||
mergeMeta("/etc", {
|
||||
{"passwd", REG, 0, 0, RW_R_R },
|
||||
{"shadow", REG, 0, 0, RW____ },
|
||||
{"pam.d", REG, 0, 0, RW____ },
|
||||
})
|
||||
|
||||
mergeMeta("/etc/pam.d", {
|
||||
{"secret", REG, 0, 0, RW____},
|
||||
})
|
||||
|
||||
kernel.log("Filesystem permissions seeded.")
|
||||
end
|
||||
@@ -0,0 +1,3 @@
|
||||
--:Minify:--
|
||||
local kernel = ...
|
||||
kernel.allowGlobalOverwrites = false
|
||||
Reference in New Issue
Block a user