This more clearly differentiates system call arguments from integer registers and return values. On current architectures it has no effect, but on architectures where pointers are not integers (CHERI) and may not even share registers (CHERI-MIPS) it is necessiary to differentiate between system call arguments (syscallarg_t) and integer register values (register_t). Obtained from: CheriBSD Reviewed by: imp, kib Differential Revision: https://reviews.freebsd.org/D33780
1621 lines
42 KiB
Lua
1621 lines
42 KiB
Lua
--
|
|
-- SPDX-License-Identifier: BSD-2-Clause-FreeBSD
|
|
--
|
|
-- Copyright (c) 2019 Kyle Evans <kevans@FreeBSD.org>
|
|
--
|
|
-- Redistribution and use in source and binary forms, with or without
|
|
-- modification, are permitted provided that the following conditions
|
|
-- are met:
|
|
-- 1. Redistributions of source code must retain the above copyright
|
|
-- notice, this list of conditions and the following disclaimer.
|
|
-- 2. Redistributions in binary form must reproduce the above copyright
|
|
-- notice, this list of conditions and the following disclaimer in the
|
|
-- documentation and/or other materials provided with the distribution.
|
|
--
|
|
-- THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
|
-- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
-- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
-- ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
|
-- FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
-- DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
-- OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
-- HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
-- LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
-- OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
-- SUCH DAMAGE.
|
|
--
|
|
-- $FreeBSD$
|
|
--
|
|
|
|
|
|
-- We generally assume that this script will be run by flua, however we've
|
|
-- carefully crafted modules for it that mimic interfaces provided by modules
|
|
-- available in ports. Currently, this script is compatible with lua from ports
|
|
-- along with the compatible luafilesystem and lua-posix modules.
|
|
local lfs = require("lfs")
|
|
local unistd = require("posix.unistd")
|
|
|
|
local savesyscall = -1
|
|
local maxsyscall = -1
|
|
local generated_tag = "@" .. "generated"
|
|
|
|
-- Default configuration; any of these may get replaced by a configuration file
|
|
-- optionally specified.
|
|
local config = {
|
|
os_id_keyword = "FreeBSD",
|
|
abi_func_prefix = "",
|
|
sysnames = "syscalls.c",
|
|
sysproto = "../sys/sysproto.h",
|
|
sysproto_h = "_SYS_SYSPROTO_H_",
|
|
syshdr = "../sys/syscall.h",
|
|
sysmk = "../sys/syscall.mk",
|
|
syssw = "init_sysent.c",
|
|
syscallprefix = "SYS_",
|
|
switchname = "sysent",
|
|
namesname = "syscallnames",
|
|
systrace = "systrace_args.c",
|
|
capabilities_conf = "capabilities.conf",
|
|
capenabled = {},
|
|
compat_set = "native",
|
|
mincompat = 0,
|
|
abi_type_suffix = "",
|
|
abi_flags = "",
|
|
abi_flags_mask = 0,
|
|
abi_headers = "",
|
|
abi_intptr_t = "intptr_t",
|
|
abi_size_t = "size_t",
|
|
abi_u_long = "u_long",
|
|
abi_long = "long",
|
|
abi_semid_t = "semid_t",
|
|
abi_ptr_array_t = "",
|
|
ptr_intptr_t_cast = "intptr_t",
|
|
syscall_abi_change = "",
|
|
sys_abi_change = {},
|
|
syscall_no_abi_change = "",
|
|
sys_no_abi_change = {},
|
|
obsol = "",
|
|
obsol_dict = {},
|
|
unimpl = "",
|
|
unimpl_dict = {},
|
|
}
|
|
|
|
local config_modified = {}
|
|
local cleantmp = true
|
|
local tmpspace = "/tmp/sysent." .. unistd.getpid() .. "/"
|
|
|
|
local output_files = {
|
|
"sysnames",
|
|
"syshdr",
|
|
"sysmk",
|
|
"syssw",
|
|
"systrace",
|
|
"sysproto",
|
|
}
|
|
|
|
-- These ones we'll create temporary files for; generation purposes.
|
|
local temp_files = {
|
|
"sysaue",
|
|
"sysdcl",
|
|
"syscompat",
|
|
"syscompatdcl",
|
|
"sysent",
|
|
"sysinc",
|
|
"sysarg",
|
|
"sysprotoend",
|
|
"systracetmp",
|
|
"systraceret",
|
|
}
|
|
|
|
-- Opened files
|
|
local files = {}
|
|
|
|
local function cleanup()
|
|
for _, v in pairs(files) do
|
|
assert(v:close())
|
|
end
|
|
if cleantmp then
|
|
if lfs.dir(tmpspace) then
|
|
for fname in lfs.dir(tmpspace) do
|
|
if fname ~= "." and fname ~= ".." then
|
|
assert(os.remove(tmpspace .. "/" ..
|
|
fname))
|
|
end
|
|
end
|
|
end
|
|
|
|
if lfs.attributes(tmpspace) and not lfs.rmdir(tmpspace) then
|
|
assert(io.stderr:write("Failed to clean up tmpdir: " ..
|
|
tmpspace .. "\n"))
|
|
end
|
|
else
|
|
assert(io.stderr:write("Temp files left in " .. tmpspace ..
|
|
"\n"))
|
|
end
|
|
end
|
|
|
|
local function abort(status, msg)
|
|
assert(io.stderr:write(msg .. "\n"))
|
|
cleanup()
|
|
os.exit(status)
|
|
end
|
|
|
|
-- Each entry should have a value so we can represent abi flags as a bitmask
|
|
-- for convenience. One may also optionally provide an expr; this gets applied
|
|
-- to each argument type to indicate whether this argument is subject to ABI
|
|
-- change given the configured flags.
|
|
local known_abi_flags = {
|
|
long_size = {
|
|
value = 0x00000001,
|
|
exprs = {
|
|
"_Contains[a-z_]*_long_",
|
|
"^long [a-z0-9_]+$",
|
|
"long [*]",
|
|
"size_t [*]",
|
|
-- semid_t is not included because it is only used
|
|
-- as an argument or written out individually and
|
|
-- said writes are handled by the ksem framework.
|
|
-- Technically a sign-extension issue exists for
|
|
-- arguments, but because semid_t is actually a file
|
|
-- descriptor negative 32-bit values are invalid
|
|
-- regardless of sign-extension.
|
|
},
|
|
},
|
|
time_t_size = {
|
|
value = 0x00000002,
|
|
exprs = {
|
|
"_Contains[a-z_]*_timet_",
|
|
},
|
|
},
|
|
pointer_args = {
|
|
value = 0x00000004,
|
|
},
|
|
pointer_size = {
|
|
value = 0x00000008,
|
|
exprs = {
|
|
"_Contains[a-z_]*_ptr_",
|
|
"[*][*]",
|
|
},
|
|
},
|
|
pair_64bit = {
|
|
value = 0x00000010,
|
|
exprs = {
|
|
"^dev_t[ ]*$",
|
|
"^id_t[ ]*$",
|
|
"^off_t[ ]*$",
|
|
},
|
|
},
|
|
}
|
|
|
|
local known_flags = {
|
|
STD = 0x00000001,
|
|
OBSOL = 0x00000002,
|
|
RESERVED = 0x00000004,
|
|
UNIMPL = 0x00000008,
|
|
NODEF = 0x00000010,
|
|
NOARGS = 0x00000020,
|
|
NOPROTO = 0x00000040,
|
|
NOSTD = 0x00000080,
|
|
NOTSTATIC = 0x00000100,
|
|
CAPENABLED = 0x00000200,
|
|
SYSMUX = 0x00000400,
|
|
|
|
-- Compat flags start from here. We have plenty of space.
|
|
}
|
|
|
|
-- All compat option entries should have five entries:
|
|
-- definition: The preprocessor macro that will be set for this
|
|
-- compatlevel: The level this compatibility should be included at. This
|
|
-- generally represents the version of FreeBSD that it is compatible
|
|
-- with, but ultimately it's just the level of mincompat in which it's
|
|
-- included.
|
|
-- flag: The name of the flag in syscalls.master.
|
|
-- prefix: The prefix to use for _args and syscall prototype. This will be
|
|
-- used as-is, without "_" or any other character appended.
|
|
-- descr: The description of this compat option in init_sysent.c comments.
|
|
-- The special "stdcompat" entry will cause the other five to be autogenerated.
|
|
local compat_option_sets = {
|
|
native = {
|
|
{
|
|
definition = "COMPAT_43",
|
|
compatlevel = 3,
|
|
flag = "COMPAT",
|
|
prefix = "o",
|
|
descr = "old",
|
|
},
|
|
{ stdcompat = "FREEBSD4" },
|
|
{ stdcompat = "FREEBSD6" },
|
|
{ stdcompat = "FREEBSD7" },
|
|
{ stdcompat = "FREEBSD10" },
|
|
{ stdcompat = "FREEBSD11" },
|
|
{ stdcompat = "FREEBSD12" },
|
|
{ stdcompat = "FREEBSD13" },
|
|
},
|
|
}
|
|
|
|
-- compat_options will be resolved to a set from the configuration.
|
|
local compat_options
|
|
|
|
local function trim(s, char)
|
|
if s == nil then
|
|
return nil
|
|
end
|
|
if char == nil then
|
|
char = "%s"
|
|
end
|
|
return s:gsub("^" .. char .. "+", ""):gsub(char .. "+$", "")
|
|
end
|
|
|
|
-- config looks like a shell script; in fact, the previous makesyscalls.sh
|
|
-- script actually sourced it in. It had a pretty common format, so we should
|
|
-- be fine to make various assumptions
|
|
local function process_config(file)
|
|
local cfg = {}
|
|
local comment_line_expr = "^%s*#.*"
|
|
-- We capture any whitespace padding here so we can easily advance to
|
|
-- the end of the line as needed to check for any trailing bogus bits.
|
|
-- Alternatively, we could drop the whitespace and instead try to
|
|
-- use a pattern to strip out the meaty part of the line, but then we
|
|
-- would need to sanitize the line for potentially special characters.
|
|
local line_expr = "^([%w%p]+%s*)=(%s*[`\"]?[^\"`]*[`\"]?)"
|
|
|
|
if not file then
|
|
return nil, "No file given"
|
|
end
|
|
|
|
local fh = assert(io.open(file))
|
|
|
|
for nextline in fh:lines() do
|
|
-- Strip any whole-line comments
|
|
nextline = nextline:gsub(comment_line_expr, "")
|
|
-- Parse it into key, value pairs
|
|
local key, value = nextline:match(line_expr)
|
|
if key ~= nil and value ~= nil then
|
|
local kvp = key .. "=" .. value
|
|
key = trim(key)
|
|
value = trim(value)
|
|
local delim = value:sub(1,1)
|
|
if delim == '"' then
|
|
local trailing_context
|
|
|
|
-- Strip off the key/value part
|
|
trailing_context = nextline:sub(kvp:len() + 1)
|
|
-- Strip off any trailing comment
|
|
trailing_context = trailing_context:gsub("#.*$",
|
|
"")
|
|
-- Strip off leading/trailing whitespace
|
|
trailing_context = trim(trailing_context)
|
|
if trailing_context ~= "" then
|
|
print(trailing_context)
|
|
abort(1, "Malformed line: " .. nextline)
|
|
end
|
|
|
|
value = trim(value, delim)
|
|
else
|
|
-- Strip off potential comments
|
|
value = value:gsub("#.*$", "")
|
|
-- Strip off any padding whitespace
|
|
value = trim(value)
|
|
if value:match("%s") then
|
|
abort(1, "Malformed config line: " ..
|
|
nextline)
|
|
end
|
|
end
|
|
cfg[key] = value
|
|
elseif not nextline:match("^%s*$") then
|
|
-- Make sure format violations don't get overlooked
|
|
-- here, but ignore blank lines. Comments are already
|
|
-- stripped above.
|
|
abort(1, "Malformed config line: " .. nextline)
|
|
end
|
|
end
|
|
|
|
assert(io.close(fh))
|
|
return cfg
|
|
end
|
|
|
|
local function grab_capenabled(file, open_fail_ok)
|
|
local capentries = {}
|
|
local commentExpr = "#.*"
|
|
|
|
if file == nil then
|
|
print "No file"
|
|
return {}
|
|
end
|
|
|
|
local fh = io.open(file)
|
|
if fh == nil then
|
|
if not open_fail_ok then
|
|
abort(1, "Failed to open " .. file)
|
|
end
|
|
return {}
|
|
end
|
|
|
|
for nextline in fh:lines() do
|
|
-- Strip any comments
|
|
nextline = nextline:gsub(commentExpr, "")
|
|
if nextline ~= "" then
|
|
capentries[nextline] = true
|
|
end
|
|
end
|
|
|
|
assert(io.close(fh))
|
|
return capentries
|
|
end
|
|
|
|
local function process_compat()
|
|
local nval = 0
|
|
for _, v in pairs(known_flags) do
|
|
if v > nval then
|
|
nval = v
|
|
end
|
|
end
|
|
|
|
nval = nval << 1
|
|
for _, v in pairs(compat_options) do
|
|
if v["stdcompat"] ~= nil then
|
|
local stdcompat = v["stdcompat"]
|
|
v["definition"] = "COMPAT_" .. stdcompat:upper()
|
|
v["compatlevel"] = tonumber(stdcompat:match("([0-9]+)$"))
|
|
v["flag"] = stdcompat:gsub("FREEBSD", "COMPAT")
|
|
v["prefix"] = stdcompat:lower() .. "_"
|
|
v["descr"] = stdcompat:lower()
|
|
end
|
|
|
|
local tmpname = "sys" .. v["flag"]:lower()
|
|
local dcltmpname = tmpname .. "dcl"
|
|
files[tmpname] = io.tmpfile()
|
|
files[dcltmpname] = io.tmpfile()
|
|
v["tmp"] = tmpname
|
|
v["dcltmp"] = dcltmpname
|
|
|
|
known_flags[v["flag"]] = nval
|
|
v["mask"] = nval
|
|
nval = nval << 1
|
|
|
|
v["count"] = 0
|
|
end
|
|
end
|
|
|
|
local function process_abi_flags()
|
|
local flags, mask = config["abi_flags"], 0
|
|
for txtflag in flags:gmatch("([^|]+)") do
|
|
if known_abi_flags[txtflag] == nil then
|
|
abort(1, "Unknown abi_flag: " .. txtflag)
|
|
end
|
|
|
|
mask = mask | known_abi_flags[txtflag]["value"]
|
|
end
|
|
|
|
config["abi_flags_mask"] = mask
|
|
end
|
|
|
|
local function process_obsol()
|
|
local obsol = config["obsol"]
|
|
for syscall in obsol:gmatch("([^ ]+)") do
|
|
config["obsol_dict"][syscall] = true
|
|
end
|
|
end
|
|
|
|
local function process_unimpl()
|
|
local unimpl = config["unimpl"]
|
|
for syscall in unimpl:gmatch("([^ ]+)") do
|
|
config["unimpl_dict"][syscall] = true
|
|
end
|
|
end
|
|
|
|
local function process_syscall_abi_change()
|
|
local changes_abi = config["syscall_abi_change"]
|
|
for syscall in changes_abi:gmatch("([^ ]+)") do
|
|
config["sys_abi_change"][syscall] = true
|
|
end
|
|
|
|
local no_changes = config["syscall_no_abi_change"]
|
|
for syscall in no_changes:gmatch("([^ ]+)") do
|
|
config["sys_no_abi_change"][syscall] = true
|
|
end
|
|
end
|
|
|
|
local function abi_changes(name)
|
|
if known_abi_flags[name] == nil then
|
|
abort(1, "abi_changes: unknown flag: " .. name)
|
|
end
|
|
|
|
return config["abi_flags_mask"] & known_abi_flags[name]["value"] ~= 0
|
|
end
|
|
|
|
local function strip_abi_prefix(funcname)
|
|
local abiprefix = config["abi_func_prefix"]
|
|
local stripped_name
|
|
if funcname == nil then
|
|
return nil
|
|
end
|
|
if abiprefix ~= "" and funcname:find("^" .. abiprefix) then
|
|
stripped_name = funcname:gsub("^" .. abiprefix, "")
|
|
else
|
|
stripped_name = funcname
|
|
end
|
|
|
|
return stripped_name
|
|
end
|
|
|
|
local function read_file(tmpfile)
|
|
if files[tmpfile] == nil then
|
|
print("Not found: " .. tmpfile)
|
|
return
|
|
end
|
|
|
|
local fh = files[tmpfile]
|
|
assert(fh:seek("set"))
|
|
return assert(fh:read("a"))
|
|
end
|
|
|
|
local function write_line(tmpfile, line)
|
|
if files[tmpfile] == nil then
|
|
print("Not found: " .. tmpfile)
|
|
return
|
|
end
|
|
assert(files[tmpfile]:write(line))
|
|
end
|
|
|
|
local function write_line_pfile(tmppat, line)
|
|
for k in pairs(files) do
|
|
if k:match(tmppat) ~= nil then
|
|
assert(files[k]:write(line))
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Check both literal intptr_t and the abi version because this needs
|
|
-- to work both before and after the substitution
|
|
local function isptrtype(type)
|
|
return type:find("*") or type:find("caddr_t") or
|
|
type:find("intptr_t") or type:find(config['abi_intptr_t'])
|
|
end
|
|
|
|
local function isptrarraytype(type)
|
|
return type:find("[*][*]") or type:find("[*][ ]*const[ ]*[*]")
|
|
end
|
|
|
|
-- Find types that are always 64-bits wide
|
|
local function is64bittype(type)
|
|
return type:find("^dev_t[ ]*$") or type:find("^id_t[ ]*$") or type:find("^off_t[ ]*$")
|
|
end
|
|
|
|
local process_syscall_def
|
|
|
|
-- These patterns are processed in order on any line that isn't empty.
|
|
local pattern_table = {
|
|
{
|
|
pattern = "%s*$" .. config['os_id_keyword'],
|
|
process = function(_, _)
|
|
-- Ignore... ID tag
|
|
end,
|
|
},
|
|
{
|
|
dump_prevline = true,
|
|
pattern = "^#%s*include",
|
|
process = function(line)
|
|
line = line .. "\n"
|
|
write_line('sysinc', line)
|
|
end,
|
|
},
|
|
{
|
|
dump_prevline = true,
|
|
pattern = "^#",
|
|
process = function(line)
|
|
if line:find("^#%s*if") then
|
|
savesyscall = maxsyscall
|
|
elseif line:find("^#%s*else") then
|
|
maxsyscall = savesyscall
|
|
end
|
|
line = line .. "\n"
|
|
write_line('sysent', line)
|
|
write_line('sysdcl', line)
|
|
write_line('sysarg', line)
|
|
write_line_pfile('syscompat[0-9]*$', line)
|
|
write_line('sysnames', line)
|
|
write_line_pfile('systrace.*', line)
|
|
end,
|
|
},
|
|
{
|
|
dump_prevline = true,
|
|
pattern = "%%ABI_HEADERS%%",
|
|
process = function()
|
|
if config['abi_headers'] ~= "" then
|
|
line = config['abi_headers'] .. "\n"
|
|
write_line('sysinc', line)
|
|
end
|
|
end,
|
|
},
|
|
{
|
|
-- Buffer anything else
|
|
pattern = ".+",
|
|
process = function(line, prevline)
|
|
local incomplete = line:find("\\$") ~= nil
|
|
-- Lines that end in \ get the \ stripped
|
|
-- Lines that start with a syscall number, prepend \n
|
|
line = trim(line):gsub("\\$", "")
|
|
if line:find("^[0-9]") and prevline then
|
|
process_syscall_def(prevline)
|
|
prevline = nil
|
|
end
|
|
|
|
prevline = (prevline or '') .. line
|
|
incomplete = incomplete or prevline:find(",$") ~= nil
|
|
incomplete = incomplete or prevline:find("{") ~= nil and
|
|
prevline:find("}") == nil
|
|
if prevline:find("^[0-9]") and not incomplete then
|
|
process_syscall_def(prevline)
|
|
prevline = nil
|
|
end
|
|
|
|
return prevline
|
|
end,
|
|
},
|
|
}
|
|
|
|
local function process_sysfile(file)
|
|
local capentries = {}
|
|
local commentExpr = "^%s*;.*"
|
|
|
|
if file == nil then
|
|
print "No file"
|
|
return {}
|
|
end
|
|
|
|
local fh = io.open(file)
|
|
if fh == nil then
|
|
print("Failed to open " .. file)
|
|
return {}
|
|
end
|
|
|
|
local function do_match(nextline, prevline)
|
|
local pattern, handler, dump
|
|
for _, v in pairs(pattern_table) do
|
|
pattern = v['pattern']
|
|
handler = v['process']
|
|
dump = v['dump_prevline']
|
|
if nextline:match(pattern) then
|
|
if dump and prevline then
|
|
process_syscall_def(prevline)
|
|
prevline = nil
|
|
end
|
|
|
|
return handler(nextline, prevline)
|
|
end
|
|
end
|
|
|
|
abort(1, "Failed to handle: " .. nextline)
|
|
end
|
|
|
|
local prevline
|
|
for nextline in fh:lines() do
|
|
-- Strip any comments
|
|
nextline = nextline:gsub(commentExpr, "")
|
|
if nextline ~= "" then
|
|
prevline = do_match(nextline, prevline)
|
|
end
|
|
end
|
|
|
|
-- Dump any remainder
|
|
if prevline ~= nil and prevline:find("^[0-9]") then
|
|
process_syscall_def(prevline)
|
|
end
|
|
|
|
assert(io.close(fh))
|
|
return capentries
|
|
end
|
|
|
|
local function get_mask(flags)
|
|
local mask = 0
|
|
for _, v in ipairs(flags) do
|
|
if known_flags[v] == nil then
|
|
abort(1, "Checking for unknown flag " .. v)
|
|
end
|
|
|
|
mask = mask | known_flags[v]
|
|
end
|
|
|
|
return mask
|
|
end
|
|
|
|
local function get_mask_pat(pflags)
|
|
local mask = 0
|
|
for k, v in pairs(known_flags) do
|
|
if k:find(pflags) then
|
|
mask = mask | v
|
|
end
|
|
end
|
|
|
|
return mask
|
|
end
|
|
|
|
local function align_sysent_comment(col)
|
|
write_line("sysent", "\t")
|
|
col = col + 8 - col % 8
|
|
while col < 56 do
|
|
write_line("sysent", "\t")
|
|
col = col + 8
|
|
end
|
|
end
|
|
|
|
local function strip_arg_annotations(arg)
|
|
arg = arg:gsub("_Contains_[^ ]*[_)] ?", "")
|
|
arg = arg:gsub("_In[^ ]*[_)] ?", "")
|
|
arg = arg:gsub("_Out[^ ]*[_)] ?", "")
|
|
return trim(arg)
|
|
end
|
|
|
|
local function check_abi_changes(arg)
|
|
for k, v in pairs(known_abi_flags) do
|
|
local exprs = v["exprs"]
|
|
if abi_changes(k) and exprs ~= nil then
|
|
for _, e in pairs(exprs) do
|
|
if arg:find(e) then
|
|
return true
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
return false
|
|
end
|
|
|
|
local function process_args(args)
|
|
local funcargs = {}
|
|
local changes_abi = false
|
|
|
|
for arg in args:gmatch("([^,]+)") do
|
|
local arg_abi_change = check_abi_changes(arg)
|
|
changes_abi = changes_abi or arg_abi_change
|
|
|
|
arg = strip_arg_annotations(arg)
|
|
|
|
local argname = arg:match("([^* ]+)$")
|
|
|
|
-- argtype is... everything else.
|
|
local argtype = trim(arg:gsub(argname .. "$", ""), nil)
|
|
|
|
if argtype == "" and argname == "void" then
|
|
goto out
|
|
end
|
|
|
|
-- is64bittype() needs a bare type so check it after argname
|
|
-- is removed
|
|
changes_abi = changes_abi or (abi_changes("pair_64bit") and is64bittype(argtype))
|
|
|
|
argtype = argtype:gsub("intptr_t", config["abi_intptr_t"])
|
|
argtype = argtype:gsub("semid_t", config["abi_semid_t"])
|
|
if isptrtype(argtype) then
|
|
argtype = argtype:gsub("size_t", config["abi_size_t"])
|
|
argtype = argtype:gsub("^long", config["abi_long"]);
|
|
argtype = argtype:gsub("^u_long", config["abi_u_long"]);
|
|
argtype = argtype:gsub("^const u_long", "const " .. config["abi_u_long"]);
|
|
elseif argtype:find("^long$") then
|
|
argtype = config["abi_long"]
|
|
end
|
|
if isptrarraytype(argtype) and config["abi_ptr_array_t"] ~= "" then
|
|
-- `* const *` -> `**`
|
|
argtype = argtype:gsub("[*][ ]*const[ ]*[*]", "**")
|
|
-- e.g., `struct aiocb **` -> `uint32_t *`
|
|
argtype = argtype:gsub("[^*]*[*]", config["abi_ptr_array_t"] .. " ", 1)
|
|
end
|
|
|
|
-- XX TODO: Forward declarations? See: sysstubfwd in CheriBSD
|
|
if arg_abi_change then
|
|
local abi_type_suffix = config["abi_type_suffix"]
|
|
argtype = argtype:gsub("(struct [^ ]*)", "%1" ..
|
|
abi_type_suffix)
|
|
argtype = argtype:gsub("(union [^ ]*)", "%1" ..
|
|
abi_type_suffix)
|
|
end
|
|
|
|
if abi_changes("pair_64bit") and is64bittype(argtype) then
|
|
if #funcargs % 2 == 1 then
|
|
funcargs[#funcargs + 1] = {
|
|
type = "int",
|
|
name = "_pad",
|
|
}
|
|
end
|
|
funcargs[#funcargs + 1] = {
|
|
type = "uint32_t",
|
|
name = argname .. "1",
|
|
}
|
|
funcargs[#funcargs + 1] = {
|
|
type = "uint32_t",
|
|
name = argname .. "2",
|
|
}
|
|
else
|
|
funcargs[#funcargs + 1] = {
|
|
type = argtype,
|
|
name = argname,
|
|
}
|
|
end
|
|
end
|
|
|
|
::out::
|
|
return funcargs, changes_abi
|
|
end
|
|
|
|
local function handle_noncompat(sysnum, thr_flag, flags, sysflags, rettype,
|
|
auditev, syscallret, funcname, funcalias, funcargs, argalias)
|
|
local argssize
|
|
|
|
if flags & known_flags["SYSMUX"] ~= 0 then
|
|
argssize = "0"
|
|
elseif #funcargs > 0 or flags & known_flags["NODEF"] ~= 0 then
|
|
argssize = "AS(" .. argalias .. ")"
|
|
else
|
|
argssize = "0"
|
|
end
|
|
|
|
write_line("systrace", string.format([[
|
|
/* %s */
|
|
case %d: {
|
|
]], funcname, sysnum))
|
|
write_line("systracetmp", string.format([[
|
|
/* %s */
|
|
case %d:
|
|
]], funcname, sysnum))
|
|
write_line("systraceret", string.format([[
|
|
/* %s */
|
|
case %d:
|
|
]], funcname, sysnum))
|
|
|
|
if #funcargs > 0 and flags & known_flags["SYSMUX"] == 0 then
|
|
write_line("systracetmp", "\t\tswitch (ndx) {\n")
|
|
write_line("systrace", string.format(
|
|
"\t\tstruct %s *p = params;\n", argalias))
|
|
|
|
|
|
local argtype, argname, desc, padding
|
|
padding = ""
|
|
for idx, arg in ipairs(funcargs) do
|
|
argtype = arg["type"]
|
|
argname = arg["name"]
|
|
|
|
argtype = trim(argtype:gsub("__restrict$", ""), nil)
|
|
if argtype == "int" and argname == "_pad" and abi_changes("pair_64bit") then
|
|
write_line("systracetmp", "#ifdef PAD64_REQUIRED\n")
|
|
end
|
|
-- Pointer arg?
|
|
if argtype:find("*") then
|
|
desc = "userland " .. argtype
|
|
else
|
|
desc = argtype;
|
|
end
|
|
write_line("systracetmp", string.format(
|
|
"\t\tcase %d%s:\n\t\t\tp = \"%s\";\n\t\t\tbreak;\n",
|
|
idx - 1, padding, desc))
|
|
if argtype == "int" and argname == "_pad" and abi_changes("pair_64bit") then
|
|
padding = " - _P_"
|
|
write_line("systracetmp", "#define _P_ 0\n#else\n#define _P_ 1\n#endif\n")
|
|
end
|
|
|
|
if isptrtype(argtype) then
|
|
write_line("systrace", string.format(
|
|
"\t\tuarg[a++] = (%s)p->%s; /* %s */\n",
|
|
config["ptr_intptr_t_cast"],
|
|
argname, argtype))
|
|
elseif argtype == "union l_semun" then
|
|
write_line("systrace", string.format(
|
|
"\t\tuarg[a++] = p->%s.buf; /* %s */\n",
|
|
argname, argtype))
|
|
elseif argtype:sub(1,1) == "u" or argtype == "size_t" then
|
|
write_line("systrace", string.format(
|
|
"\t\tuarg[a++] = p->%s; /* %s */\n",
|
|
argname, argtype))
|
|
else
|
|
if argtype == "int" and argname == "_pad" and abi_changes("pair_64bit") then
|
|
write_line("systrace", "#ifdef PAD64_REQUIRED\n")
|
|
end
|
|
write_line("systrace", string.format(
|
|
"\t\tiarg[a++] = p->%s; /* %s */\n",
|
|
argname, argtype))
|
|
if argtype == "int" and argname == "_pad" and abi_changes("pair_64bit") then
|
|
write_line("systrace", "#endif\n")
|
|
end
|
|
end
|
|
end
|
|
|
|
write_line("systracetmp",
|
|
"\t\tdefault:\n\t\t\tbreak;\n\t\t};\n")
|
|
if padding ~= "" then
|
|
write_line("systracetmp", "#undef _P_\n\n")
|
|
end
|
|
|
|
write_line("systraceret", string.format([[
|
|
if (ndx == 0 || ndx == 1)
|
|
p = "%s";
|
|
break;
|
|
]], syscallret))
|
|
end
|
|
local n_args = #funcargs
|
|
if flags & known_flags["SYSMUX"] ~= 0 then
|
|
n_args = 0
|
|
end
|
|
write_line("systrace", string.format(
|
|
"\t\t*n_args = %d;\n\t\tbreak;\n\t}\n", n_args))
|
|
write_line("systracetmp", "\t\tbreak;\n")
|
|
|
|
local nargflags = get_mask({"NOARGS", "NOPROTO", "NODEF"})
|
|
if flags & nargflags == 0 then
|
|
if #funcargs > 0 then
|
|
write_line("sysarg", string.format("struct %s {\n",
|
|
argalias))
|
|
for _, v in ipairs(funcargs) do
|
|
local argname, argtype = v["name"], v["type"]
|
|
if argtype == "int" and argname == "_pad" and abi_changes("pair_64bit") then
|
|
write_line("sysarg", "#ifdef PAD64_REQUIRED\n")
|
|
end
|
|
write_line("sysarg", string.format(
|
|
"\tchar %s_l_[PADL_(%s)]; %s %s; char %s_r_[PADR_(%s)];\n",
|
|
argname, argtype,
|
|
argtype, argname,
|
|
argname, argtype))
|
|
if argtype == "int" and argname == "_pad" and abi_changes("pair_64bit") then
|
|
write_line("sysarg", "#endif\n")
|
|
end
|
|
end
|
|
write_line("sysarg", "};\n")
|
|
else
|
|
write_line("sysarg", string.format(
|
|
"struct %s {\n\tsyscallarg_t dummy;\n};\n", argalias))
|
|
end
|
|
end
|
|
|
|
local protoflags = get_mask({"NOPROTO", "NODEF"})
|
|
if flags & protoflags == 0 then
|
|
if funcname == "nosys" or funcname == "lkmnosys" or
|
|
funcname == "sysarch" or funcname:find("^freebsd") or
|
|
funcname:find("^linux") then
|
|
write_line("sysdcl", string.format(
|
|
"%s\t%s(struct thread *, struct %s *)",
|
|
rettype, funcname, argalias))
|
|
else
|
|
write_line("sysdcl", string.format(
|
|
"%s\tsys_%s(struct thread *, struct %s *)",
|
|
rettype, funcname, argalias))
|
|
end
|
|
write_line("sysdcl", ";\n")
|
|
write_line("sysaue", string.format("#define\t%sAUE_%s\t%s\n",
|
|
config['syscallprefix'], funcalias, auditev))
|
|
end
|
|
|
|
write_line("sysent",
|
|
string.format("\t{ .sy_narg = %s, .sy_call = (sy_call_t *)", argssize))
|
|
local column = 8 + 2 + #argssize + 15
|
|
|
|
if flags & known_flags["SYSMUX"] ~= 0 then
|
|
write_line("sysent", string.format(
|
|
"nosys, .sy_auevent = AUE_NULL, " ..
|
|
".sy_flags = %s, .sy_thrcnt = SY_THR_STATIC },",
|
|
sysflags))
|
|
column = column + #"nosys" + #"AUE_NULL" + 3
|
|
elseif flags & known_flags["NOSTD"] ~= 0 then
|
|
write_line("sysent", string.format(
|
|
"lkmressys, .sy_auevent = AUE_NULL, " ..
|
|
".sy_flags = %s, .sy_thrcnt = SY_THR_ABSENT },",
|
|
sysflags))
|
|
column = column + #"lkmressys" + #"AUE_NULL" + 3
|
|
else
|
|
if funcname == "nosys" or funcname == "lkmnosys" or
|
|
funcname == "sysarch" or funcname:find("^freebsd") or
|
|
funcname:find("^linux") then
|
|
write_line("sysent", string.format(
|
|
"%s, .sy_auevent = %s, .sy_flags = %s, .sy_thrcnt = %s },",
|
|
funcname, auditev, sysflags, thr_flag))
|
|
column = column + #funcname + #auditev + #sysflags + 3
|
|
else
|
|
write_line("sysent", string.format(
|
|
"sys_%s, .sy_auevent = %s, .sy_flags = %s, .sy_thrcnt = %s },",
|
|
funcname, auditev, sysflags, thr_flag))
|
|
column = column + #funcname + #auditev + #sysflags + 7
|
|
end
|
|
end
|
|
|
|
align_sysent_comment(column)
|
|
write_line("sysent", string.format("/* %d = %s */\n",
|
|
sysnum, funcalias))
|
|
write_line("sysnames", string.format("\t\"%s\",\t\t\t/* %d = %s */\n",
|
|
funcalias, sysnum, funcalias))
|
|
|
|
if flags & known_flags["NODEF"] == 0 then
|
|
write_line("syshdr", string.format("#define\t%s%s\t%d\n",
|
|
config['syscallprefix'], funcalias, sysnum))
|
|
write_line("sysmk", string.format(" \\\n\t%s.o",
|
|
funcalias))
|
|
end
|
|
end
|
|
|
|
local function handle_obsol(sysnum, funcname, comment)
|
|
write_line("sysent",
|
|
"\t{ .sy_narg = 0, .sy_call = (sy_call_t *)nosys, " ..
|
|
".sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT },")
|
|
align_sysent_comment(34)
|
|
|
|
write_line("sysent", string.format("/* %d = obsolete %s */\n",
|
|
sysnum, comment))
|
|
write_line("sysnames", string.format(
|
|
"\t\"obs_%s\",\t\t\t/* %d = obsolete %s */\n",
|
|
funcname, sysnum, comment))
|
|
write_line("syshdr", string.format("\t\t\t\t/* %d is obsolete %s */\n",
|
|
sysnum, comment))
|
|
end
|
|
|
|
local function handle_compat(sysnum, thr_flag, flags, sysflags, rettype,
|
|
auditev, funcname, funcalias, funcargs, argalias)
|
|
local argssize, out, outdcl, wrap, prefix, descr
|
|
|
|
if #funcargs > 0 or flags & known_flags["NODEF"] ~= 0 then
|
|
argssize = "AS(" .. argalias .. ")"
|
|
else
|
|
argssize = "0"
|
|
end
|
|
|
|
for _, v in pairs(compat_options) do
|
|
if flags & v["mask"] ~= 0 then
|
|
if config["mincompat"] > v["compatlevel"] then
|
|
funcname = strip_abi_prefix(funcname)
|
|
funcname = v["prefix"] .. funcname
|
|
return handle_obsol(sysnum, funcname, funcname)
|
|
end
|
|
v["count"] = v["count"] + 1
|
|
out = v["tmp"]
|
|
outdcl = v["dcltmp"]
|
|
wrap = v["flag"]:lower()
|
|
prefix = v["prefix"]
|
|
descr = v["descr"]
|
|
goto compatdone
|
|
end
|
|
end
|
|
|
|
::compatdone::
|
|
local dprotoflags = get_mask({"NOPROTO", "NODEF"})
|
|
local nargflags = dprotoflags | known_flags["NOARGS"]
|
|
if #funcargs > 0 and flags & nargflags == 0 then
|
|
write_line(out, string.format("struct %s {\n", argalias))
|
|
for _, v in ipairs(funcargs) do
|
|
local argname, argtype = v["name"], v["type"]
|
|
write_line(out, string.format(
|
|
"\tchar %s_l_[PADL_(%s)]; %s %s; char %s_r_[PADR_(%s)];\n",
|
|
argname, argtype,
|
|
argtype, argname,
|
|
argname, argtype))
|
|
end
|
|
write_line(out, "};\n")
|
|
elseif flags & nargflags == 0 then
|
|
write_line("sysarg", string.format(
|
|
"struct %s {\n\tsyscallarg_t dummy;\n};\n", argalias))
|
|
end
|
|
if flags & dprotoflags == 0 then
|
|
write_line(outdcl, string.format(
|
|
"%s\t%s%s(struct thread *, struct %s *);\n",
|
|
rettype, prefix, funcname, argalias))
|
|
write_line("sysaue", string.format(
|
|
"#define\t%sAUE_%s%s\t%s\n", config['syscallprefix'],
|
|
prefix, funcname, auditev))
|
|
end
|
|
|
|
if flags & known_flags['NOSTD'] ~= 0 then
|
|
write_line("sysent", string.format(
|
|
"\t{ .sy_narg = %s, .sy_call = (sy_call_t *)%s, " ..
|
|
".sy_auevent = %s, .sy_flags = 0, " ..
|
|
".sy_thrcnt = SY_THR_ABSENT },",
|
|
"0", "lkmressys", "AUE_NULL"))
|
|
align_sysent_comment(8 + 2 + #"0" + 15 + #"lkmressys" +
|
|
#"AUE_NULL" + 3)
|
|
else
|
|
write_line("sysent", string.format(
|
|
"\t{ %s(%s,%s), .sy_auevent = %s, .sy_flags = %s, .sy_thrcnt = %s },",
|
|
wrap, argssize, funcname, auditev, sysflags, thr_flag))
|
|
align_sysent_comment(8 + 9 + #argssize + 1 + #funcname +
|
|
#auditev + #sysflags + 4)
|
|
end
|
|
|
|
write_line("sysent", string.format("/* %d = %s %s */\n",
|
|
sysnum, descr, funcalias))
|
|
write_line("sysnames", string.format(
|
|
"\t\"%s.%s\",\t\t/* %d = %s %s */\n",
|
|
wrap, funcalias, sysnum, descr, funcalias))
|
|
-- Do not provide freebsdN_* symbols in libc for < FreeBSD 7
|
|
local nosymflags = get_mask({"COMPAT", "COMPAT4", "COMPAT6"})
|
|
if flags & nosymflags ~= 0 then
|
|
write_line("syshdr", string.format(
|
|
"\t\t\t\t/* %d is %s %s */\n",
|
|
sysnum, descr, funcalias))
|
|
elseif flags & known_flags["NODEF"] == 0 then
|
|
write_line("syshdr", string.format("#define\t%s%s%s\t%d\n",
|
|
config['syscallprefix'], prefix, funcalias, sysnum))
|
|
write_line("sysmk", string.format(" \\\n\t%s%s.o",
|
|
prefix, funcalias))
|
|
end
|
|
end
|
|
|
|
local function handle_unimpl(sysnum, sysstart, sysend, comment)
|
|
if sysstart == nil and sysend == nil then
|
|
sysstart = tonumber(sysnum)
|
|
sysend = tonumber(sysnum)
|
|
end
|
|
|
|
sysnum = sysstart
|
|
while sysnum <= sysend do
|
|
write_line("sysent", string.format(
|
|
"\t{ .sy_narg = 0, .sy_call = (sy_call_t *)nosys, " ..
|
|
".sy_auevent = AUE_NULL, .sy_flags = 0, " ..
|
|
".sy_thrcnt = SY_THR_ABSENT },\t\t\t/* %d = %s */\n",
|
|
sysnum, comment))
|
|
write_line("sysnames", string.format(
|
|
"\t\"#%d\",\t\t\t/* %d = %s */\n",
|
|
sysnum, sysnum, comment))
|
|
sysnum = sysnum + 1
|
|
end
|
|
end
|
|
|
|
local function handle_reserved(sysnum, sysstart, sysend, comment)
|
|
handle_unimpl(sysnum, sysstart, sysend, "reserved for local use")
|
|
end
|
|
|
|
process_syscall_def = function(line)
|
|
local sysstart, sysend, flags, funcname, sysflags
|
|
local thr_flag, syscallret
|
|
local orig = line
|
|
flags = 0
|
|
thr_flag = "SY_THR_STATIC"
|
|
|
|
-- Parse out the interesting information first
|
|
local initialExpr = "^([^%s]+)%s+([^%s]+)%s+([^%s]+)%s*"
|
|
local sysnum, auditev, allflags = line:match(initialExpr)
|
|
|
|
if sysnum == nil or auditev == nil or allflags == nil then
|
|
-- XXX TODO: Better?
|
|
abort(1, "Completely malformed: " .. line)
|
|
end
|
|
|
|
if sysnum:find("-") then
|
|
sysstart, sysend = sysnum:match("^([%d]+)-([%d]+)$")
|
|
if sysstart == nil or sysend == nil then
|
|
abort(1, "Malformed range: " .. sysnum)
|
|
end
|
|
sysnum = nil
|
|
sysstart = tonumber(sysstart)
|
|
sysend = tonumber(sysend)
|
|
if sysstart ~= maxsyscall + 1 then
|
|
abort(1, "syscall number out of sync, missing " ..
|
|
maxsyscall + 1)
|
|
end
|
|
else
|
|
sysnum = tonumber(sysnum)
|
|
if sysnum ~= maxsyscall + 1 then
|
|
abort(1, "syscall number out of sync, missing " ..
|
|
maxsyscall + 1)
|
|
end
|
|
end
|
|
|
|
-- Split flags
|
|
for flag in allflags:gmatch("([^|]+)") do
|
|
if known_flags[flag] == nil then
|
|
abort(1, "Unknown flag " .. flag .. " for " .. sysnum)
|
|
end
|
|
flags = flags | known_flags[flag]
|
|
end
|
|
|
|
if (flags & get_mask({"RESERVED", "UNIMPL"})) == 0 and sysnum == nil then
|
|
abort(1, "Range only allowed with RESERVED and UNIMPL: " .. line)
|
|
end
|
|
|
|
if (flags & known_flags["NOTSTATIC"]) ~= 0 then
|
|
thr_flag = "SY_THR_ABSENT"
|
|
end
|
|
|
|
-- Strip earlier bits out, leave declaration + alt
|
|
line = line:gsub("^.+" .. allflags .. "%s*", "")
|
|
|
|
local decl_fnd = line:find("^{") ~= nil
|
|
if decl_fnd and line:find("}") == nil then
|
|
abort(1, "Malformed, no closing brace: " .. line)
|
|
end
|
|
|
|
local decl, alt
|
|
if decl_fnd then
|
|
line = line:gsub("^{", "")
|
|
decl, alt = line:match("([^}]*)}[%s]*(.*)$")
|
|
else
|
|
alt = line
|
|
end
|
|
|
|
if decl == nil and alt == nil then
|
|
abort(1, "Malformed bits: " .. line)
|
|
end
|
|
|
|
local funcalias, funcomment, argalias, rettype, args
|
|
if not decl_fnd and alt ~= nil and alt ~= "" then
|
|
-- Peel off one entry for name
|
|
funcname = trim(alt:match("^([^%s]+)"), nil)
|
|
alt = alt:gsub("^([^%s]+)[%s]*", "")
|
|
end
|
|
-- Do we even need it?
|
|
if flags & get_mask({"OBSOL", "UNIMPL"}) ~= 0 then
|
|
local NF = 0
|
|
for _ in orig:gmatch("[^%s]+") do
|
|
NF = NF + 1
|
|
end
|
|
|
|
funcomment = funcname or ''
|
|
if NF < 6 then
|
|
funcomment = funcomment .. " " .. alt
|
|
end
|
|
|
|
funcomment = trim(funcomment)
|
|
|
|
-- if funcname ~= nil then
|
|
-- else
|
|
-- funcomment = trim(alt)
|
|
-- end
|
|
goto skipalt
|
|
end
|
|
|
|
if alt ~= nil and alt ~= "" then
|
|
local altExpr = "^([^%s]+)%s+([^%s]+)%s+([^%s]+)"
|
|
funcalias, argalias, rettype = alt:match(altExpr)
|
|
funcalias = trim(funcalias)
|
|
if funcalias == nil or argalias == nil or rettype == nil then
|
|
abort(1, "Malformed alt: " .. line)
|
|
end
|
|
end
|
|
if decl_fnd then
|
|
-- Don't clobber rettype set in the alt information
|
|
if rettype == nil then
|
|
rettype = "int"
|
|
end
|
|
-- Peel off the return type
|
|
syscallret = line:match("([^%s]+)%s")
|
|
line = line:match("[^%s]+%s(.+)")
|
|
-- Pointer incoming
|
|
if line:sub(1,1) == "*" then
|
|
syscallret = syscallret .. " "
|
|
end
|
|
while line:sub(1,1) == "*" do
|
|
line = line:sub(2)
|
|
syscallret = syscallret .. "*"
|
|
end
|
|
funcname = line:match("^([^(]+)%(")
|
|
if funcname == nil then
|
|
abort(1, "Not a signature? " .. line)
|
|
end
|
|
args = line:match("^[^(]+%((.+)%)[^)]*$")
|
|
args = trim(args, '[,%s]')
|
|
end
|
|
|
|
::skipalt::
|
|
|
|
if funcname == nil then
|
|
funcname = funcalias
|
|
end
|
|
|
|
funcname = trim(funcname)
|
|
|
|
if config["obsol_dict"][funcname] then
|
|
local compat_prefix = ""
|
|
for _, v in pairs(compat_options) do
|
|
if flags & v["mask"] ~= 0 then
|
|
compat_prefix = v["prefix"]
|
|
goto obsol_compat_done
|
|
end
|
|
end
|
|
::obsol_compat_done::
|
|
args = nil
|
|
flags = known_flags['OBSOL']
|
|
funcomment = compat_prefix .. funcname
|
|
end
|
|
if config["unimpl_dict"][funcname] then
|
|
flags = known_flags['UNIMPL']
|
|
funcomment = funcname
|
|
end
|
|
|
|
sysflags = "0"
|
|
|
|
-- NODEF events do not get audited
|
|
if flags & known_flags['NODEF'] ~= 0 then
|
|
auditev = 'AUE_NULL'
|
|
end
|
|
|
|
-- If applicable; strip the ABI prefix from the name
|
|
local stripped_name = strip_abi_prefix(funcname)
|
|
|
|
if flags & known_flags['CAPENABLED'] ~= 0 or
|
|
config["capenabled"][funcname] ~= nil or
|
|
config["capenabled"][stripped_name] ~= nil then
|
|
sysflags = "SYF_CAPENABLED"
|
|
end
|
|
|
|
local funcargs = {}
|
|
local changes_abi = false
|
|
if args ~= nil then
|
|
funcargs, changes_abi = process_args(args)
|
|
end
|
|
if config["sys_no_abi_change"][funcname] then
|
|
changes_abi = false
|
|
end
|
|
local noproto = config["abi_flags"] ~= "" and not changes_abi
|
|
|
|
local argprefix = ''
|
|
local funcprefix = ''
|
|
if abi_changes("pointer_args") then
|
|
for _, v in ipairs(funcargs) do
|
|
if isptrtype(v["type"]) then
|
|
if config["sys_no_abi_change"][funcname] then
|
|
print("WARNING: " .. funcname ..
|
|
" in syscall_no_abi_change, but pointers args are present")
|
|
end
|
|
changes_abi = true
|
|
goto ptrfound
|
|
end
|
|
end
|
|
::ptrfound::
|
|
end
|
|
if config["sys_abi_change"][funcname] then
|
|
changes_abi = true
|
|
end
|
|
if changes_abi then
|
|
-- argalias should be:
|
|
-- COMPAT_PREFIX + ABI Prefix + funcname
|
|
argprefix = config['abi_func_prefix']
|
|
funcprefix = config['abi_func_prefix']
|
|
funcalias = funcprefix .. funcname
|
|
noproto = false
|
|
end
|
|
if funcname ~= nil then
|
|
funcname = funcprefix .. funcname
|
|
end
|
|
if funcalias == nil or funcalias == "" then
|
|
funcalias = funcname
|
|
end
|
|
|
|
if argalias == nil and funcname ~= nil then
|
|
argalias = funcname .. "_args"
|
|
for _, v in pairs(compat_options) do
|
|
local mask = v["mask"]
|
|
if (flags & mask) ~= 0 then
|
|
-- Multiple aliases doesn't seem to make
|
|
-- sense.
|
|
argalias = v["prefix"] .. argalias
|
|
goto out
|
|
end
|
|
end
|
|
::out::
|
|
elseif argalias ~= nil then
|
|
argalias = argprefix .. argalias
|
|
end
|
|
|
|
local ncompatflags = get_mask({"STD", "NODEF", "NOARGS", "NOPROTO",
|
|
"NOSTD"})
|
|
local compatflags = get_mask_pat("COMPAT.*")
|
|
if noproto or flags & known_flags["SYSMUX"] ~= 0 then
|
|
flags = flags | known_flags["NOPROTO"];
|
|
end
|
|
if flags & known_flags["OBSOL"] ~= 0 then
|
|
handle_obsol(sysnum, funcname, funcomment)
|
|
elseif flags & known_flags["RESERVED"] ~= 0 then
|
|
handle_reserved(sysnum, sysstart, sysend)
|
|
elseif flags & known_flags["UNIMPL"] ~= 0 then
|
|
handle_unimpl(sysnum, sysstart, sysend, funcomment)
|
|
elseif flags & compatflags ~= 0 then
|
|
if flags & known_flags['STD'] ~= 0 then
|
|
abort(1, "Incompatible COMPAT/STD: " .. line)
|
|
end
|
|
handle_compat(sysnum, thr_flag, flags, sysflags, rettype,
|
|
auditev, funcname, funcalias, funcargs, argalias)
|
|
elseif flags & ncompatflags ~= 0 then
|
|
handle_noncompat(sysnum, thr_flag, flags, sysflags, rettype,
|
|
auditev, syscallret, funcname, funcalias, funcargs,
|
|
argalias)
|
|
else
|
|
abort(1, "Bad flags? " .. line)
|
|
end
|
|
|
|
if sysend ~= nil then
|
|
maxsyscall = sysend
|
|
elseif sysnum ~= nil then
|
|
maxsyscall = sysnum
|
|
end
|
|
end
|
|
|
|
-- Entry point
|
|
|
|
if #arg < 1 or #arg > 2 then
|
|
error("usage: " .. arg[0] .. " input-file <config-file>")
|
|
end
|
|
|
|
local sysfile, configfile = arg[1], arg[2]
|
|
|
|
-- process_config either returns nil and a message, or a
|
|
-- table that we should merge into the global config
|
|
if configfile ~= nil then
|
|
local res = assert(process_config(configfile))
|
|
|
|
for k, v in pairs(res) do
|
|
if v ~= config[k] then
|
|
config[k] = v
|
|
config_modified[k] = true
|
|
end
|
|
end
|
|
end
|
|
|
|
local compat_set = config['compat_set']
|
|
if compat_set ~= "" then
|
|
if not compat_option_sets[compat_set] then
|
|
abort(1, "Undefined compat set: " .. compat_set)
|
|
end
|
|
|
|
compat_options = compat_option_sets[compat_set]
|
|
else
|
|
compat_options = {}
|
|
end
|
|
|
|
-- We ignore errors here if we're relying on the default configuration.
|
|
if not config_modified["capenabled"] then
|
|
config["capenabled"] = grab_capenabled(config['capabilities_conf'],
|
|
config_modified["capabilities_conf"] == nil)
|
|
elseif config["capenabled"] ~= "" then
|
|
-- Due to limitations in the config format mostly, we'll have a comma
|
|
-- separated list. Parse it into lines
|
|
local capenabled = {}
|
|
-- print("here: " .. config["capenabled"])
|
|
for sysc in config["capenabled"]:gmatch("([^,]+)") do
|
|
capenabled[sysc] = true
|
|
end
|
|
config["capenabled"] = capenabled
|
|
end
|
|
process_compat()
|
|
process_abi_flags()
|
|
process_syscall_abi_change()
|
|
process_obsol()
|
|
process_unimpl()
|
|
|
|
if not lfs.mkdir(tmpspace) then
|
|
error("Failed to create tempdir " .. tmpspace)
|
|
end
|
|
|
|
-- XXX Revisit the error handling here, we should probably move the rest of this
|
|
-- into a function that we pcall() so we can catch the errors and clean up
|
|
-- gracefully.
|
|
for _, v in ipairs(temp_files) do
|
|
local tmpname = tmpspace .. v
|
|
files[v] = io.open(tmpname, "w+")
|
|
-- XXX Revisit these with a pcall() + error handler
|
|
if not files[v] then
|
|
abort(1, "Failed to open temp file: " .. tmpname)
|
|
end
|
|
end
|
|
|
|
for _, v in ipairs(output_files) do
|
|
local tmpname = tmpspace .. v
|
|
files[v] = io.open(tmpname, "w+")
|
|
-- XXX Revisit these with a pcall() + error handler
|
|
if not files[v] then
|
|
abort(1, "Failed to open temp output file: " .. tmpname)
|
|
end
|
|
end
|
|
|
|
-- Write out all of the preamble bits
|
|
write_line("sysent", string.format([[
|
|
|
|
/* The casts are bogus but will do for now. */
|
|
struct sysent %s[] = {
|
|
]], config['switchname']))
|
|
|
|
write_line("syssw", string.format([[/*
|
|
* System call switch table.
|
|
*
|
|
* DO NOT EDIT-- this file is automatically %s.
|
|
* $%s$
|
|
*/
|
|
|
|
]], generated_tag, config['os_id_keyword']))
|
|
|
|
write_line("sysarg", string.format([[/*
|
|
* System call prototypes.
|
|
*
|
|
* DO NOT EDIT-- this file is automatically %s.
|
|
* $%s$
|
|
*/
|
|
|
|
#ifndef %s
|
|
#define %s
|
|
|
|
#include <sys/signal.h>
|
|
#include <sys/acl.h>
|
|
#include <sys/cpuset.h>
|
|
#include <sys/domainset.h>
|
|
#include <sys/_ffcounter.h>
|
|
#include <sys/_semaphore.h>
|
|
#include <sys/ucontext.h>
|
|
#include <sys/wait.h>
|
|
|
|
#include <bsm/audit_kevents.h>
|
|
|
|
struct proc;
|
|
|
|
struct thread;
|
|
|
|
#define PAD_(t) (sizeof(syscallarg_t) <= sizeof(t) ? \
|
|
0 : sizeof(syscallarg_t) - sizeof(t))
|
|
|
|
#if BYTE_ORDER == LITTLE_ENDIAN
|
|
#define PADL_(t) 0
|
|
#define PADR_(t) PAD_(t)
|
|
#else
|
|
#define PADL_(t) PAD_(t)
|
|
#define PADR_(t) 0
|
|
#endif
|
|
|
|
]], generated_tag, config['os_id_keyword'], config['sysproto_h'],
|
|
config['sysproto_h']))
|
|
if abi_changes("pair_64bit") then
|
|
write_line("sysarg", string.format([[
|
|
#if !defined(PAD64_REQUIRED) && !defined(__amd64__)
|
|
#define PAD64_REQUIRED
|
|
#endif
|
|
]]))
|
|
end
|
|
if abi_changes("pair_64bit") then
|
|
write_line("systrace", string.format([[
|
|
#if !defined(PAD64_REQUIRED) && !defined(__amd64__)
|
|
#define PAD64_REQUIRED
|
|
#endif
|
|
]]))
|
|
end
|
|
for _, v in pairs(compat_options) do
|
|
write_line(v["tmp"], string.format("\n#ifdef %s\n\n", v["definition"]))
|
|
end
|
|
|
|
write_line("sysnames", string.format([[/*
|
|
* System call names.
|
|
*
|
|
* DO NOT EDIT-- this file is automatically %s.
|
|
* $%s$
|
|
*/
|
|
|
|
const char *%s[] = {
|
|
]], generated_tag, config['os_id_keyword'], config['namesname']))
|
|
|
|
write_line("syshdr", string.format([[/*
|
|
* System call numbers.
|
|
*
|
|
* DO NOT EDIT-- this file is automatically %s.
|
|
* $%s$
|
|
*/
|
|
|
|
]], generated_tag, config['os_id_keyword']))
|
|
|
|
write_line("sysmk", string.format([[# FreeBSD system call object files.
|
|
# DO NOT EDIT-- this file is automatically %s.
|
|
# $%s$
|
|
MIASM = ]], generated_tag, config['os_id_keyword']))
|
|
|
|
write_line("systrace", string.format([[/*
|
|
* System call argument to DTrace register array converstion.
|
|
*
|
|
* DO NOT EDIT-- this file is automatically %s.
|
|
* $%s$
|
|
* This file is part of the DTrace syscall provider.
|
|
*/
|
|
|
|
static void
|
|
systrace_args(int sysnum, void *params, uint64_t *uarg, int *n_args)
|
|
{
|
|
int64_t *iarg = (int64_t *)uarg;
|
|
int a = 0;
|
|
switch (sysnum) {
|
|
]], generated_tag, config['os_id_keyword']))
|
|
|
|
write_line("systracetmp", [[static void
|
|
systrace_entry_setargdesc(int sysnum, int ndx, char *desc, size_t descsz)
|
|
{
|
|
const char *p = NULL;
|
|
switch (sysnum) {
|
|
]])
|
|
|
|
write_line("systraceret", [[static void
|
|
systrace_return_setargdesc(int sysnum, int ndx, char *desc, size_t descsz)
|
|
{
|
|
const char *p = NULL;
|
|
switch (sysnum) {
|
|
]])
|
|
|
|
-- Processing the sysfile will parse out the preprocessor bits and put them into
|
|
-- the appropriate place. Any syscall-looking lines get thrown into the sysfile
|
|
-- buffer, one per line, for later processing once they're all glued together.
|
|
process_sysfile(sysfile)
|
|
|
|
write_line("sysinc",
|
|
"\n#define AS(name) (sizeof(struct name) / sizeof(syscallarg_t))\n")
|
|
|
|
for _, v in pairs(compat_options) do
|
|
if v["count"] > 0 then
|
|
write_line("sysinc", string.format([[
|
|
|
|
#ifdef %s
|
|
#define %s(n, name) .sy_narg = n, .sy_call = (sy_call_t *)__CONCAT(%s, name)
|
|
#else
|
|
#define %s(n, name) .sy_narg = 0, .sy_call = (sy_call_t *)nosys
|
|
#endif
|
|
]], v["definition"], v["flag"]:lower(), v["prefix"], v["flag"]:lower()))
|
|
end
|
|
|
|
write_line(v["dcltmp"], string.format("\n#endif /* %s */\n\n",
|
|
v["definition"]))
|
|
end
|
|
|
|
write_line("sysprotoend", string.format([[
|
|
|
|
#undef PAD_
|
|
#undef PADL_
|
|
#undef PADR_
|
|
|
|
#endif /* !%s */
|
|
]], config["sysproto_h"]))
|
|
|
|
write_line("sysmk", "\n")
|
|
write_line("sysent", "};\n")
|
|
write_line("sysnames", "};\n")
|
|
-- maxsyscall is the highest seen; MAXSYSCALL should be one higher
|
|
write_line("syshdr", string.format("#define\t%sMAXSYSCALL\t%d\n",
|
|
config["syscallprefix"], maxsyscall + 1))
|
|
write_line("systrace", [[
|
|
default:
|
|
*n_args = 0;
|
|
break;
|
|
};
|
|
}
|
|
]])
|
|
|
|
write_line("systracetmp", [[
|
|
default:
|
|
break;
|
|
};
|
|
if (p != NULL)
|
|
strlcpy(desc, p, descsz);
|
|
}
|
|
]])
|
|
|
|
write_line("systraceret", [[
|
|
default:
|
|
break;
|
|
};
|
|
if (p != NULL)
|
|
strlcpy(desc, p, descsz);
|
|
}
|
|
]])
|
|
|
|
-- Finish up; output
|
|
write_line("syssw", read_file("sysinc"))
|
|
write_line("syssw", read_file("sysent"))
|
|
|
|
write_line("sysproto", read_file("sysarg"))
|
|
write_line("sysproto", read_file("sysdcl"))
|
|
for _, v in pairs(compat_options) do
|
|
write_line("sysproto", read_file(v["tmp"]))
|
|
write_line("sysproto", read_file(v["dcltmp"]))
|
|
end
|
|
write_line("sysproto", read_file("sysaue"))
|
|
write_line("sysproto", read_file("sysprotoend"))
|
|
|
|
write_line("systrace", read_file("systracetmp"))
|
|
write_line("systrace", read_file("systraceret"))
|
|
|
|
for _, v in ipairs(output_files) do
|
|
local target = config[v]
|
|
if target ~= "/dev/null" then
|
|
local fh = assert(io.open(target, "w+"))
|
|
if fh == nil then
|
|
abort(1, "Failed to open '" .. target .. "'")
|
|
end
|
|
assert(fh:write(read_file(v)))
|
|
assert(fh:close())
|
|
end
|
|
end
|
|
|
|
cleanup()
|