rename luarocks.module to lua.module, platform.linux.driver to platform.linux.module

1 files changed, 326 insertions, 0 deletions

diff --git a/xmake/rules/platform/linux/module/driver_modules.lua b/xmake/rules/platform/linux/module/driver_modules.lua
new file mode 100644
index 000000000..8218a972c
--- /dev/null
+++ b/xmake/rules/platform/linux/module/driver_modules.lua
@@ -0,0 +1,326 @@
+--!A cross-platform build utility based on Lua
+--
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--     http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+--
+-- Copyright (C) 2015-present, TBOOX Open Source Group.
+--
+-- @author      ruki
+-- @file        driver_modules.lua
+--
+
+-- imports
+import("core.base.option")
+import("core.project.depend")
+import("core.cache.memcache")
+import("lib.detect.find_tool")
+import("utils.progress")
+
+-- get linux-headers sdk
+function _get_linux_headers_sdk(target)
+    local linux_headersdir = target:values("linux.driver.linux-headers")
+    local linux_builddir = target:values("linux.driver.linux-builddir")
+    if linux_headersdir then
+        return {
+            sdkdir = linux_headersdir,
+            builddir = linux_builddir,
+            includedir = path.join(linux_headersdir, "include")
+        }
+    end
+    local linux_headers = assert(target:pkg("linux-headers"), "please add `add_requires(\"linux-headers\", {configs = {driver_modules = true}})` and `add_packages(\"linux-headers\")` to the given target!")
+    local includedirs = linux_headers:get("includedirs") or linux_headers:get("sysincludedirs")
+    local version = linux_headers:version()
+    local includedir
+    for _, dir in ipairs(includedirs) do
+        if dir:find("linux-headers", 1, true) then
+            includedir = dir
+            linux_headersdir = path.directory(dir)
+            break
+        end
+    end
+    assert(linux_headersdir, "linux-headers not found!")
+    if not os.isfile(path.join(includedir, "generated/autoconf.h")) and
+        not os.isfile(path.join(includedir, "config/auto.conf")) then
+        raise("kernel configuration is invalid. include/generated/autoconf.h or include/config/auto.conf are missing.")
+    end
+    return {version = version, sdkdir = linux_headersdir, includedir = includedir}
+end
+
+-- get cflags from make
+function _get_cflags_from_make(target, sdkdir, builddir)
+    local key = sdkdir .. target:arch()
+    local cflags = memcache.get2("linux.driver", key, "cflags")
+    local ldflags_o = memcache.get2("linux.driver", key, "ldflags_o")
+    local ldflags_ko = memcache.get2("linux.driver", key, "ldflags_ko")
+    if cflags == nil then
+        local make = assert(find_tool("make"), "make not found!")
+        local tmpdir = os.tmpfile() .. ".dir"
+        local makefile = path.join(tmpdir, "Makefile")
+        local stubfile = path.join(tmpdir, "src/stub.c")
+        local foofile  = path.join(tmpdir, "src/foo.c")
+        io.writefile(makefile, [[obj-m := stub.o
+stub-objs := src/stub.o src/foo.o]])
+        io.writefile(foofile, "")
+        io.writefile(stubfile, [[
+#include <linux/init.h>
+#include <linux/module.h>
+
+MODULE_LICENSE("Dual BSD/GPL");
+MODULE_AUTHOR("Ruki");
+MODULE_DESCRIPTION("A simple Hello World Module");
+MODULE_ALIAS("a simplest module");
+
+static int hello_init(void) {
+    printk(KERN_INFO "Hello World\n");
+    return 0;
+}
+
+static void hello_exit(void) {
+    printk(KERN_INFO "Goodbye World\n");
+}
+
+module_init(hello_init);
+module_exit(hello_exit);
+        ]])
+        local argv = {"-C", sdkdir, "V=1", "M=" .. tmpdir, "modules"}
+        if builddir then
+            table.insert(argv, "O=" .. builddir)
+        end
+        if not target:is_plat(os.subhost()) then
+            -- e.g.	$(MAKE) -C $(KERN_DIR) V=1 ARCH=arm64 CROSS_COMPILE=/mnt/gcc-linaro-7.5.0-2019.12-x86_64_aarch64-linux-gnu/bin/aarch64-linux-gnu- M=$(PWD) modules
+            local arch
+            if target:is_arch("arm", "armv7") then
+                arch = "arm"
+            elseif target:is_arch("arm64", "arm64-v8a") then
+                arch = "arm64"
+            elseif target:is_arch("mips") then
+                arch = "mips"
+            elseif target:is_arch("ppc", "ppc64", "powerpc", "powerpc64") then
+                arch = "powerpc"
+            end
+            assert(arch, "unknown arch(%s)!", target:arch())
+            local cc = target:tool("cc")
+            local cross = cc:gsub("%-gcc$", "-")
+            table.insert(argv, "ARCH=" .. arch)
+            table.insert(argv, "CROSS_COMPILE=" .. cross)
+        end
+        local result, errors = try {function () return os.iorunv(make.program, argv, {curdir = tmpdir}) end}
+        if result then
+            -- we can also split ';' for the muliple commands
+            for _, line in ipairs(result:split("[\n;]")) do
+                line = line:trim()
+                if line:endswith("stub.c") then
+                    local include_cflag = false
+                    for _, cflag in ipairs(line:split("%s+")) do
+                        local has_cflag = false
+                        if cflag:startswith("-fplugin=") then
+                            -- @see https://github.com/xmake-io/xmake/issues/3279
+                            local plugindir = cflag:sub(10)
+                            if not path.is_absolute(plugindir) then
+                                plugindir = path.absolute(plugindir, sdkdir)
+                            end
+                            cflag = "-fplugin=" .. plugindir
+                            has_cflag = true
+                        elseif cflag:startswith("-f") or cflag:startswith("-m")
+                            or (cflag:startswith("-W") and not cflag:startswith("-Wp,-MMD,") and not cflag:startswith("-Wp,-MD,"))
+                            or (cflag:startswith("-D") and not cflag:find("KBUILD_MODNAME=") and not cflag:find("KBUILD_BASENAME=")) then
+                            has_cflag = true
+                            local macro = cflag:match("%-D\"(.+)\"") -- -D"KBUILD_XXX=xxx"
+                            if macro then
+                                cflag = "-D" .. macro
+                            end
+                        elseif cflag == "-I" or cflag == "-isystem" or cflag == "-include" then
+                            include_cflag = cflag
+                        elseif cflag:startswith("-I") or include_cflag then
+                            local includedir = cflag
+                            if cflag:startswith("-I") then
+                                includedir = cflag:sub(3)
+                            end
+                            if not path.is_absolute(includedir) then
+                                includedir = path.absolute(includedir, builddir or sdkdir)
+                            end
+                            if cflag:startswith("-I") then
+                                cflag = "-I" .. includedir
+                            else
+                                cflag = include_cflag .. " " .. includedir
+                            end
+                            has_cflag = true
+                            include_cflag = nil
+                        end
+                        if has_cflag then
+                            cflags = cflags or {}
+                            table.insert(cflags, cflag)
+                        end
+                    end
+                end
+                local ldflags = line:match("%-ld (.+) %-o ") or line:match("ld (.+) %-o ")
+                if ldflags then
+                    local ko = ldflags:find("-T ", 1, true)
+                    for _, ldflag in ipairs(os.argv(ldflags)) do
+                        if ldflag:endswith(".lds") then
+                            if not path.is_absolute(ldflag) then
+                                ldflag = path.absolute(ldflag, builddir or sdkdir)
+                            end
+                        end
+                        if ko then
+                            -- e.g. aarch64-linux-gnu-ld -r -EL  -maarch64elf --build-id=sha1  -T scripts/module.lds -o hello.ko hello.o hello.mod.o
+                            ldflags_ko = ldflags_ko or {}
+                            table.insert(ldflags_ko, ldflag)
+                        else
+                            -- e.g. aarch64-linux-gnu-ld -EL  -maarch64elf   -r -o hello.o xxx.o
+                            ldflags_o = ldflags_o or {}
+                            table.insert(ldflags_o, ldflag)
+                        end
+                    end
+                end
+                if cflags and ldflags_o and ldflags_ko then
+                    break
+                end
+            end
+        else
+            if option.get("diagnosis") then
+                print("rule(platform.linux.driver): cannot get cflags from make!")
+                print(errors)
+            end
+        end
+        os.tryrm(tmpdir)
+        memcache.set2("linux.driver", key, "cflags", cflags or false)
+        memcache.set2("linux.driver", key, "ldflags_o", ldflags_o or false)
+        memcache.set2("linux.driver", key, "ldflags_ko", ldflags_ko or false)
+    end
+    return cflags or nil, ldflags_o or nil, ldflags_ko or nil
+end
+
+function load(target)
+    -- we only need binary kind, because we will rewrite on_link
+    target:set("kind", "binary")
+    target:set("extension", ".ko")
+end
+
+function config(target)
+
+    -- get and save linux-headers sdk
+    local linux_headers = _get_linux_headers_sdk(target)
+    target:data_set("linux.driver.linux_headers", linux_headers)
+
+    -- check compiler, we must use gcc
+    assert(target:has_tool("cc", "gcc"), "we must use gcc compiler!")
+
+    -- check rules
+    for _, rulename in ipairs({"mode.release", "mode.debug", "mode.releasedbg", "mode.minsizerel", "mode.asan", "mode.tsan"}) do
+        assert(not target:rule(rulename), "target(%s) is linux driver module, it need not rule(%s)!", target:name(), rulename)
+    end
+
+    -- we need to disable includedirs from add_packages("linux-headers")
+    if target:pkg("linux-headers") then
+        target:pkg("linux-headers"):set("includedirs", nil)
+        target:pkg("linux-headers"):set("sysincludedirs", nil)
+    end
+
+    -- add compilation flags
+    target:add("defines", "KBUILD_MODNAME=\"" .. target:name() .. "\"")
+    for _, sourcefile in ipairs(target:sourcefiles()) do
+        target:fileconfig_set(sourcefile, {defines = "KBUILD_BASENAME=\"" .. path.basename(sourcefile) .. "\""})
+    end
+    local cflags, ldflags_o, ldflags_ko = _get_cflags_from_make(target, linux_headers.sdkdir, linux_headers.builddir)
+    if cflags then
+        target:add("cflags", cflags, {force = true})
+        target:data_set("linux.driver.ldflags_o", ldflags_o)
+        target:data_set("linux.driver.ldflags_ko", ldflags_ko)
+    end
+end
+
+function link(target, opt)
+    local targetfile  = target:targetfile()
+    local dependfile  = target:dependfile(targetfile)
+    local objectfiles = target:objectfiles()
+    depend.on_changed(function ()
+
+        -- trace
+        progress.show(opt.progress, "${color.build.object}linking.$(mode) %s", targetfile)
+
+        -- get module scripts
+        local modpost
+        local linux_headers = target:data("linux.driver.linux_headers")
+        if linux_headers then
+            modpost = path.join(linux_headers.builddir or linux_headers.sdkdir, "scripts", "mod", "modpost")
+        end
+        assert(modpost and os.isfile(modpost), "scripts/mod/modpost not found!")
+
+        -- get ld
+        local ld = target:tool("ld")
+        assert(ld, "ld not found!")
+        ld = ld:gsub("gcc$", "ld")
+        ld = ld:gsub("g%+%+$", "ld")
+
+        -- link target.o
+        local argv = {}
+        local ldflags_o = target:data("linux.driver.ldflags_o")
+        if ldflags_o then
+            table.join2(argv, ldflags_o)
+        end
+        local targetfile_o = target:objectfile(targetfile)
+        table.join2(argv, "-o", targetfile_o)
+        table.join2(argv, objectfiles)
+        os.mkdir(path.directory(targetfile_o))
+        os.vrunv(ld, argv)
+
+        -- generate target.mod
+        local targetfile_mod = targetfile_o:gsub("%.o$", ".mod")
+        io.writefile(targetfile_mod, table.concat(objectfiles, "\n") .. "\n\n")
+
+        -- generate .sourcename.o.cmd
+        -- we only need to touch an empty file, otherwise modpost command will raise error.
+        for _, objectfile in ipairs(objectfiles) do
+            local objectdir = path.directory(objectfile)
+            local objectname = path.filename(objectfile)
+            local cmdfile = path.join(objectdir, "." .. objectname .. ".cmd")
+            io.writefile(cmdfile, "")
+        end
+
+        -- generate target.mod.c
+        local orderfile = path.join(path.directory(targetfile_o), "modules.order")
+        local symversfile = path.join(path.directory(targetfile_o), "Module.symvers")
+        argv = {"-m", "-a", "-o", symversfile, "-e", "-N", "-w", "-T", orderfile}
+        io.writefile(orderfile, targetfile_o .. "\n")
+        os.vrunv(modpost, argv)
+
+        -- compile target.mod.c
+        local targetfile_mod_c = targetfile_o:gsub("%.o$", ".mod.c")
+        local targetfile_mod_o = targetfile_o:gsub("%.o$", ".mod.o")
+        local compinst = target:compiler("cc")
+        if option.get("verbose") then
+            print(compinst:compcmd(targetfile_mod_c, targetfile_mod_o, {target = target, rawargs = true}))
+        end
+        assert(compinst:compile(targetfile_mod_c, targetfile_mod_o, {target = target}))
+
+        -- link target.ko
+        argv = {}
+        local ldflags_ko = target:data("linux.driver.ldflags_ko")
+        if ldflags_ko then
+            table.join2(argv, ldflags_ko)
+        end
+        local targetfile_o = target:objectfile(targetfile)
+        table.join2(argv, "-o", targetfile, targetfile_o, targetfile_mod_o)
+        os.mkdir(path.directory(targetfile))
+        os.vrunv(ld, argv)
+
+    end, {dependfile = dependfile, lastmtime = os.mtime(target:targetfile()), files = objectfiles, changed = target:is_rebuilt()})
+end
+
+function install(target)
+    os.vrunv("insmod", {target:targetfile()})
+end
+
+function uninstall(target)
+    os.vrunv("rmmod", {target:targetfile()})
+end