408 lines
13 KiB
Plaintext
408 lines
13 KiB
Plaintext
--:Minify:--
|
|
local kernel = ...
|
|
local tasks = {}
|
|
local sys = {}
|
|
local nextpid = 2
|
|
kernel.exitMain = false
|
|
|
|
|
|
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 kernel.log("Failed to load executable: " .. tostring(err).. " : ".. tostring(path)); 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, clearFds)
|
|
local id = nextpid
|
|
nextpid = nextpid + 1
|
|
|
|
local fds={}
|
|
if not clearFds then
|
|
for id, file in pairs(kernel.currentTask.fd) do
|
|
file.refcount=file.refcount+1
|
|
fds[id]=file
|
|
end
|
|
end
|
|
|
|
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 = fds,
|
|
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, clearFds)
|
|
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, clearFds)
|
|
end
|
|
|
|
function sys.execspawn(path, name, envars, args, tgid, keepFds)
|
|
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, not keepFds)
|
|
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 or {}
|
|
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 = {}
|
|
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"
|
|
elseif task.euid ~= kernel.uid and kernel.uid ~= 0 then
|
|
return false, "Different user"
|
|
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"
|
|
elseif task.euid ~= kernel.uid and kernel.uid ~= 0 then
|
|
return false, "Different user"
|
|
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"
|
|
elseif task.euid ~= kernel.uid and kernel.uid ~= 0 then
|
|
return false, "Different user"
|
|
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
|
|
|
|
function sys.reapDeadTasks()
|
|
for pid, task in pairs(tasks) do
|
|
if task.status == "Z" and not task.reapTime then
|
|
if task.pid == 1 then kernel.panic("Attempted to gc init!") end
|
|
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
|
|
|
|
kernel.execPerTask(function(task)
|
|
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 == "DS" and kernel.EFI:getEpochMs() >= task.sleep then
|
|
task.status = "D"
|
|
task.sleep = 0
|
|
end
|
|
|
|
if task.status == "D" then
|
|
if task.io then
|
|
local ret = {xpcall(task.io, debug.traceback)}
|
|
if not ret[1] then
|
|
task.syscallReturn = {false, table.unpack(ret, 2)}
|
|
task.status = "R"
|
|
task.io=nil
|
|
elseif #ret>1 then
|
|
task.syscallReturn = {true, table.unpack(ret, 2)}
|
|
task.status = "R"
|
|
task.io=nil
|
|
end
|
|
end
|
|
end
|
|
end,1)
|
|
|
|
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
|