lbkit 0.8.5__tar.gz → 0.8.7__tar.gz

{lbkit-0.8.5/lbkit.egg-info → lbkit-0.8.7}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: lbkit
-Version: 0.8.5
+Version: 0.8.7
 Summary: Tools provided by litebmc.com
 Home-page: https://www.litebmc.com
 Author: xuhj@litebmc.com
@@ -21,12 +21,14 @@ Requires-Dist: requests
 Requires-Dist: gitpython
 Requires-Dist: inflection
 Requires-Dist: meson>=1.4.0
+Requires-Dist: psutil
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: summary
 

lbkit-0.8.7/lbkit/__init__.py

@@ -0,0 +1,2 @@
+
+__version__ = '0.8.7'

{lbkit-0.8.5 → lbkit-0.8.7}/lbkit/cli.py

@@ -79,6 +79,8 @@ class Command(object):
         """
         env = EnvDetector()
         if env.component:
+            os.chdir(env.component.folder)
+            print(os.getcwd())
             arg_parser = ArgParser.new()
             build = BuildComponent(arg_parser, sys.argv[2:])
             build.run()
@@ -101,6 +103,10 @@ class Command(object):
 
         组件DT用例执行
         """
+        env = EnvDetector()
+        if not env.component:
+            raise Exception("The metadata/package.yml file was not detected, not a valid litebmc component.")
+        os.chdir(env.component.folder)
         argv = sys.argv[2:]
         build = TestComponent(argv)
         build.run()
@@ -239,11 +245,9 @@ def main(args):
     shutil.rmtree(misc.LOG_DIR, ignore_errors=True)
     os.makedirs(misc.LOG_DIR, exist_ok=True)
     def ctrl_c_handler(_, __):
-        print('You pressed Ctrl+C!')
         sys.exit(-3)
 
     def sigterm_handler(_, __):
-        print('Received SIGTERM!')
         sys.exit(-4)
 
     signal.signal(signal.SIGINT, ctrl_c_handler)

{lbkit-0.8.5 → lbkit-0.8.7}/lbkit/codegen/codegen.py

@@ -67,8 +67,9 @@ history_versions = {
     "5.0": CodeGenHistory("lb_base/[>=0.8.1 <0.9.0]", "简化接口类名定义;简化枚举变量在接口间传递时的字符串定义", "0"),
     "5.1": CodeGenHistory("lb_base/[>=0.8.3 <0.9.0]", "方法和信号添加保留字段用于功能扩展，同时设置请求和响应为空标志位", "8002"),
     "5.2": CodeGenHistory("lb_base/[>=0.8.4 <0.9.0]", "支持校验数值边界、字符串正则以及数组匹配等规则", "8004"),
+    "5.3": CodeGenHistory("lb_base/[>=0.8.5 <0.9.0]", "支持32位操作系统", "8004"),
 }
-__version__=Version("5.1")
+__version__=Version("5.3")
 
 
 def version_check(ver_str: str):

{lbkit-0.8.5 → lbkit-0.8.7}/lbkit/codegen/ctype_defination.py

@@ -93,9 +93,9 @@ class IdfValidator():
             val_str = f"static const gchar *_items[] = {{"
             val_str += '"' + '", "'.join(self.matches) + '", NULL'
         else:
-            if self.ctype in ["int16", "int32", "int64"]:
+            if self.ctype in ["int16", "int32", "int64", "ssize"]:
                 val_str = f"static gint64 _items[] = {{"
-            elif self.ctype in ["uint8", "uint16", "uint32", "uint64"]:
+            elif self.ctype in ["uint8", "uint16", "uint32", "uint64", "size"]:
                 val_str = f"static guint64 _items[] = {{"
             elif self.ctype in ["double"]:
                 val_str = f"static gdouble _items[] = {{"
@@ -784,17 +784,17 @@ CTYPE_OBJS = {
         ["gsize <arg_name>"],
         ["gsize *<arg_name>"],
         [],
-        ["<arg_out> = g_variant_new_uint64(<arg_name>)"],
-        ["<arg_in> = g_variant_get_uint64(<arg_name>)"],
-        IntegerValidator("uint64", 0xffff_ffff_ffff_ffff, 0)
+        ["<arg_out> = g_variant_new_tsize(<arg_name>)"],
+        ["<arg_in> = g_variant_get_tsize(<arg_name>)"],
+        IntegerValidator("size", 0xffff_ffff_ffff_ffff, 0)
     ),
     "ssize": CTypeBase(
         ["gssize <arg_name>"],
         ["gssize *<arg_name>"],
         [],
-        ["<arg_out> = g_variant_new_int64(<arg_name>)"],
-        ["<arg_in> = g_variant_get_int64(<arg_name>)"],
-        IntegerValidator("int64", 0x7fff_ffff_ffff_ffff, -(0x8000_0000_0000_0000), True)
+        ["<arg_out> = g_variant_new_tssize(<arg_name>)"],
+        ["<arg_in> = g_variant_get_tssize(<arg_name>)"],
+        IntegerValidator("ssize", 0x7fff_ffff_ffff_ffff, -(0x8000_0000_0000_0000), True)
     ),
     "double": CTypeBase(
         ["gdouble <arg_name>"],
@@ -921,17 +921,17 @@ CTYPE_OBJS = {
         ["gsize n_<arg_name>" ,"<const>gssize *<arg_name>"],
         ["gsize *n_<arg_name>" ,"gssize **<arg_name>"],
         ["lb_free_p((void **)&<arg_name>)"],
-        ["<arg_out> = lb_array_int64_encode(<arg_name>, n_<arg_name>)"],
-        ["<arg_in> = lb_array_int64_decode(<arg_name>, &n_<arg_in>)"],
-        IntegerArrayValidator("int64",0x7fff_ffff_ffff_ffff, -(0x8000_0000_0000_0000), True)
+        ["<arg_out> = lb_array_ssize_encode(<arg_name>, n_<arg_name>)"],
+        ["<arg_in> = lb_array_ssize_decode(<arg_name>, &n_<arg_in>)"],
+        IntegerArrayValidator("ssize",0x7fff_ffff_ffff_ffff, -(0x8000_0000_0000_0000), True)
     ),
     "array[size]": CTypeBase(
         ["gsize n_<arg_name>" ,"<const>gsize *<arg_name>"],
         ["gsize *n_<arg_name>" ,"gsize **<arg_name>"],
         ["lb_free_p((void **)&<arg_name>)"],
-        ["<arg_out> = lb_array_uint64_encode(<arg_name>, n_<arg_name>)"],
-        ["<arg_in> = lb_array_uint64_decode(<arg_name>, &n_<arg_in>)"],
-        IntegerArrayValidator("uint64", 0xffff_ffff_ffff_ffff, 0)
+        ["<arg_out> = lb_array_size_encode(<arg_name>, n_<arg_name>)"],
+        ["<arg_in> = lb_array_size_decode(<arg_name>, &n_<arg_in>)"],
+        IntegerArrayValidator("size", 0xffff_ffff_ffff_ffff, 0)
     ),
     "array[double]": CTypeBase(
         ["gsize n_<arg_name>" ,"<const>gdouble *<arg_name>"],

{lbkit-0.8.5 → lbkit-0.8.7}/lbkit/codegen/template/public.c.mako

@@ -526,7 +526,7 @@ static ${name}${dictionary.key} *${name}_lookup(const ${name} *dict, ${key_decla
     }
 
     const ${name}Real *dict_real = CONTAINER_OF(dict, ${name}Real, dict);
-    return (${name}${dictionary.key} *)g_hash_table_lookup(dict_real->_hash, GUINT_TO_POINTER((guint64)key));
+    return (${name}${dictionary.key} *)g_hash_table_lookup(dict_real->_hash, GUINT_TO_POINTER(key));
 }
 
 /**
@@ -547,7 +547,7 @@ static gboolean ${name}_insert(const ${name} *dict, ${key_declare}, ${name}${dic
     % if dictionary.key_type in ["string", "object_path", "signature"]:
     gboolean ret = g_hash_table_insert(dict_real->_hash, g_strdup(key), *value);
     % else:
-    gboolean ret = g_hash_table_insert(dict_real->_hash, GUINT_TO_POINTER((guint64)key), *value);
+    gboolean ret = g_hash_table_insert(dict_real->_hash, GUINT_TO_POINTER(key), *value);
     % endif
     if (ret) {
         *value = NULL;
@@ -571,7 +571,7 @@ static gboolean ${name}_remove(const ${name} *dict, ${key_declare})
     }
 
     const ${name}Real *dict_real = CONTAINER_OF(dict, ${name}Real, dict);
-    return g_hash_table_remove(dict_real->_hash, GUINT_TO_POINTER((guint64)key));
+    return g_hash_table_remove(dict_real->_hash, GUINT_TO_POINTER(key));
 }
 
 /**

{lbkit-0.8.5 → lbkit-0.8.7}/lbkit/component/build.py

@@ -20,7 +20,6 @@ from lbkit.codegen.codegen import Version
 
 tools = Tools("comp_build")
 log = tools.log
-cwd = os.getcwd()
 lb_cwd = os.path.split(os.path.realpath(__file__))[0]
 
 
@@ -52,6 +51,7 @@ class DeployComponent():
 
 class BuildComponent():
     def __init__(self, args_parser: ArgumentParser, args=None):
+        self.cwd = os.getcwd()
         self.deploy_success = True
         self.options = args_parser.parse_args(args)
         self.options.build_type = self.options.build_type.capitalize()
@@ -64,7 +64,7 @@ class BuildComponent():
         self.verbose = False if self.options.summary else True
         self.from_source = self.options.from_source
         # 当前组件及其依赖将被部署到rootfs目录
-        self.rootfs_dir = os.path.join(cwd, ".temp", "rootfs")
+        self.rootfs_dir = os.path.join(self.cwd, ".temp", "rootfs")
         shutil.rmtree(self.rootfs_dir, ignore_errors=True)
         os.makedirs(self.rootfs_dir, exist_ok=True)
 
@@ -117,7 +117,7 @@ class BuildComponent():
         return False
 
     def gen_conaninfo(self):
-        package_yml = os.path.join(cwd, "metadata/package.yml")
+        package_yml = os.path.join(self.cwd, "metadata/package.yml")
         if not os.path.isfile(package_yml):
             raise FileNotFoundError("metadata/package.yml文件不存在")
         # 验证失败时抛异常，此处不用处理，由外层处理
@@ -155,10 +155,10 @@ class BuildComponent():
                 self.base_cmd += f" -o {conan}/*:{k}={v}"
 
         # 生成conan构建脚本
-        conanfile = os.path.join(cwd, "conanbase.py")
+        conanfile = os.path.join(self.cwd, "conanbase.py")
         # 当git未跟踪conanfile.py时生成新的conanfile.py
         if not self._is_conanfile_tracked:
-            conanfile = os.path.join(cwd, "conanfile.py")
+            conanfile = os.path.join(self.cwd, "conanfile.py")
 
         # 使用litebmc.conanfile.mako模板生成基础litebmc公共conanfile
         lookup = TemplateLookup(directories=os.path.join(lb_cwd, "template"))
@@ -210,8 +210,8 @@ class BuildComponent():
         # import sys
         # sys.exit(-1)
 
-        lockfile = os.path.join(cwd, ".temp", "conan.lock")
-        graphfile = os.path.join(cwd, ".temp", "graph.info")
+        lockfile = os.path.join(self.cwd, ".temp", "conan.lock")
+        graphfile = os.path.join(self.cwd, ".temp", "graph.info")
         lock_cmd = f"conan lock create . {self.base_cmd} --lockfile-out={lockfile}"
         tools.run(lock_cmd, capture_output=False)
         graph_cmd = f"conan graph info . {self.base_cmd} -f json --lockfile={lockfile}"
@@ -232,7 +232,7 @@ class BuildComponent():
 
         # 设置ROOTFS_DIR环境变量，为DT测试提供相对路径
         os.environ["ROOTFS_DIR"] = self.rootfs_dir
-        os.chdir(cwd)
+        os.chdir(self.cwd)
 
     def _validate_odf_object(self, name, obj):
         properties = obj.get("properties")
@@ -276,7 +276,7 @@ class BuildComponent():
         for root, _, files in os.walk(self.rootfs_dir):
             for file in files:
                 file = os.path.join(root, file)
-                file = os.path.relpath(file, cwd)
+                file = os.path.relpath(file, self.cwd)
                 if not file.endswith(".yaml"):
                     log.debug(f"file {file} not endswith .yaml, skip validate")
                     continue

{lbkit-0.8.5 → lbkit-0.8.7}/lbkit/component/test.py

@@ -12,11 +12,11 @@ from lbkit.misc import Color
 
 tool = Tools("comp_test")
 log = tool.log
-cwd = os.getcwd()
 
 
 class TestComponent():
     def __init__(self, args=None):
+        self.cwd = os.getcwd()
         self.build_parser = ArgParser.new(True)
         self.build_parser.parse_args(args) # 共享命令参数
         self.origin_args = args
@@ -95,13 +95,13 @@ class TestComponent():
         self._make_ld_library_path(build.rootfs_dir)
 
         # 为确保路径正确，切换到初始路径
-        os.chdir(cwd)
+        os.chdir(self.cwd)
         # 必须存在test.py时才测试
         if not os.path.isfile("test.py"):
             log.warn("Test file(test.py) not exist, skip test")
             return 0
         # 从test.py加载LiteBmcComponentTest实例并运行用命
-        loader = importlib.machinery.SourceFileLoader("test", os.path.join(cwd, "test.py"))
+        loader = importlib.machinery.SourceFileLoader("test", os.path.join(self.cwd, "test.py"))
         mod = loader.load_module()
         klass = getattr(mod, "LiteBmcComponentTest")
         if klass is None:

{lbkit-0.8.5 → lbkit-0.8.7}/lbkit/misc.py

@@ -5,6 +5,7 @@ import json
 import yaml
 import re
 import requests
+import fcntl
 from string import Template
 from colorama import Fore, Style
 from jsonschema import validate, ValidationError
@@ -104,3 +105,43 @@ def load_yml_with_json_schema_validate(yml_file, default_json_schema_file, **kwa
         raise PackageConfigException(f"validate {yml_file} failed, schema file is {schema_file}, "
                                      f"message: {exc.message}\n"
                                      "installing redhat.vscode-yaml plugin in vscode will help you write odf files")
+
+class DownloadFlag():
+    @staticmethod
+    def clean(filename):
+        """清理文件标记"""
+        filename += ".flag"
+        fp = open(filename, "a+")
+        fcntl.flock(fp, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        fp.truncate(0)
+        fcntl.flock(fp, fcntl.F_UNLCK)
+        fp.close()
+
+    @staticmethod
+    def create(filename, url, new_hash):
+        """创建文件标记"""
+        filename += ".flag"
+        fp = open(filename, "a+")
+        fcntl.flock(fp, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        fp.seek(0, 0)
+        fp.truncate(0)
+        fp.write(url + "|" + new_hash)
+        fcntl.flock(fp, fcntl.F_UNLCK)
+        fp.close()
+
+    @staticmethod
+    def read(filename):
+        """读取文件标记"""
+        filename += ".flag"
+        if not os.path.isfile(filename):
+            return "", ""
+        fp = open(filename, "a+")
+        fcntl.flock(fp, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        fp.seek(0, 0)
+        content = fp.read()
+        fcntl.flock(fp, fcntl.F_UNLCK)
+        fp.close()
+        if len(content) == 0:
+            return "", ""
+        chunk = content.split("|")
+        return chunk[0], chunk[1]

{lbkit-0.8.5 → lbkit-0.8.7}/lbkit/tasks/config.py

@@ -15,6 +15,7 @@ class Config(object):
 
         # 配置项
         self.manifest = os.path.join(os.getcwd(), args.manifest)
+        self.manifest = os.path.realpath(self.manifest)
         # 配置项目录
         self.work_dir = os.path.dirname(self.manifest)
         sys.path.append(self.work_dir)
@@ -32,13 +33,14 @@ class Config(object):
 
         # 编译主机配置项
         self.profile_build = args.profile_build
-        # 编译目标配置项
-        self.profile_host = args.profile
+        # 待所有参数确认后会调用refresh_profile_name设置正确的profile
+        self.profile_host = None
 
         # conan.lock options
         self.using_lockfile = args.lockfile
         self.update_lockfile = args.update_lockfile
         self.target = args.target
+        self.product = args.product
 
         # 设置并创建构建所需目录
         log.info("Work dir: %s", self.work_dir)
@@ -47,20 +49,22 @@ class Config(object):
         self.output_path = os.path.join(self.temp_path, "output")
         self.download_path = os.path.join(self.temp_path, "download")
         self.tool_path = os.path.join(self.temp_path, "tools")
+        self.compiler_path = os.path.join(self.tool_path, "compiler")
         # conan组件打包目录
         self.conan_install = []
         self.mnt_path = os.path.join(self.temp_path, "mnt_path")
         self.rootfs_img = os.path.join(self.output_path, "rootfs.img")
         # rootfs、uboot和kernel关键文件路径
-        self.uboot_bin = None
-        self.linux_bin = None
-        self.rootfs_tar = None
         os.makedirs(self.temp_path, exist_ok=True)
         os.makedirs(self.tool_path, exist_ok=True)
         os.makedirs(self.output_path, exist_ok=True)
         os.makedirs(self.download_path, exist_ok=True)
+        os.makedirs(self.compiler_path, exist_ok=True)
         # 制作rootfs时需要strip镜像，所以需要单独指定stip路径
         self.strip = "strip"
+        self.check_product()
+        # 刷新conan profile
+        self.refresh_profile_name()
 
     @staticmethod
     def target_list():
@@ -79,12 +83,12 @@ class Config(object):
         parser = argparse.ArgumentParser(description="Build LiteBMC", formatter_class=argparse.RawTextHelpFormatter)
         parser.add_argument("-m", "--manifest", help="Specify the manifest.yml, ignored when -l is specified.", default="./manifest.yml")
         parser.add_argument("-s", "--from_source", help="Build from source", action="store_true")
-        parser.add_argument("-pr", "--profile", help="Apply the specified profile to the host machine", default="litebmc.ini")
         parser.add_argument("-pr:b", "--profile_build", help="Apply the specified profile to the build machine", default="default")
         parser.add_argument("-bt", "--build_type", type=str, choices=['debug', 'release', 'minsize'], help="Set the build type", default="debug")
         parser.add_argument("-r", "--remote", help="specified conan server", default="litebmc")
         parser.add_argument("-l", "--lockfile", help="using conan.lock", action="store_true")
         parser.add_argument("-ul", "--update_lockfile", help="update conan.lock", action="store_true")
+        parser.add_argument("-p", "--product", help="product name, default product is `default`", default="default")
         targets = Config.target_list()
         target_help = "build target:"
         for tgt, _ in targets.items():
@@ -102,6 +106,45 @@ class Config(object):
                 return default
         return manifest
 
+    @staticmethod
+    def merge_cfg(dst, src):
+        """合并两个配置项"""
+        # 如果源为None，则返回dst
+        if src is None:
+            return dst
+        # 如果目标是空的，直接返回src
+        if not dst:
+            return src
+        # 如果是数组、标量的直接覆盖dst即可，所以返回src
+        if not isinstance(dst, dict):
+            return src
+        # 如果目标非空，但源是空，直接返回目标
+        if not src:
+            return dst
+        if not isinstance(src, dict):
+            raise Exception(f"Merge configuration failed, source config {src} is not a dictionary")
+        output = {}
+        for key, val in src.items():
+            dst_val = dst.get(key)
+            output[key] = Config.merge_cfg(dst_val, val)
+        for key, val in dst.items():
+            # 已经合并过，即目标中存在，但源不存在，直接合并
+            if key in output:
+                continue
+            output[key] = val
+        return output
+
+    def get_product_config(self, key: str, default=None):
+        """获取产品配置，注意，key只需要基于products/[name]/即可，如 toolchain"""
+        global_cfg = self.get_manifest_config(key, default)
+        key = f"products/{self.product}/{key}"
+        product_cfg = self.get_manifest_config(key, None)
+        if not product_cfg:
+            return global_cfg
+        if not global_cfg:
+            return product_cfg
+        return Config.merge_cfg(global_cfg, product_cfg)
+
     def load_manifest(self):
         """加载manifest.yml并验证schema文件"""
         template = {}
@@ -110,6 +153,19 @@ class Config(object):
         template["download_path"] = os.path.join(self.download_path)
         return load_yml_with_json_schema_validate(self.manifest, "/usr/share/litebmc/schema/pdf.v1.json", **template)
 
+    def check_product(self):
+        products = self.get_manifest_config("products", {})
+        if products.get(self.product):
+            return
+        log.error(f"Only the following products are supported:")
+        for key, _ in products.items():
+            log.info("    * " + key)
+        # todo: 待manifest.yml整改到位到删除下面注释
+        # raise Exception(f"Unkown product {self.product}")
+
+    def refresh_profile_name(self):
+        self.profile_host = self.get_product_config("toolchain/profile/name", "litebmc")
+
     def set_build_type(self, value):
         self.build_type = value
 

{lbkit-0.8.5 → lbkit-0.8.7}/lbkit/tasks/executor.py

@@ -3,7 +3,9 @@
 import importlib
 import os
 import time
+import traceback
 import sys
+import psutil
 
 from multiprocessing import Process
 from multiprocessing import Manager
@@ -138,6 +140,7 @@ def task_handler(te:TaskExecutor):
     try:
         ret = te.run()
     except Exception as e:
+        traceback.print_exc()
         log.error(f"Task {te.status_key} exit with exceiption: {str(e)}")
         with status_lock:
             status_dict[te.status_key] = TASK_STATUS_EXCEPT
@@ -158,6 +161,19 @@ class TaskInfo():
         self.proc = proc
 
 
+def kill_process_and_children(pid):
+    try:
+        parent = psutil.Process(pid)
+    except psutil.NoSuchProcess:
+        return
+
+    children = parent.children(recursive=True)
+    for child in children:
+        child.terminate()
+
+    parent.terminate()
+
+
 def wait_tasks(tasks: dict[str, TaskInfo], alow_processes_alive=0):
     while True:
         new_results = {}
@@ -170,13 +186,12 @@ def wait_tasks(tasks: dict[str, TaskInfo], alow_processes_alive=0):
                 continue
             with status_lock:
                 status = status_dict.get(ti.te.status_key)
-            if status == TASK_STATUS_EXCEPT:
+            if status == TASK_STATUS_EXCEPT or status == TASK_STATUS_FAILED:
                 killall = True
                 break
         if killall:
             for _, ti in tasks.items():
-                if ti.proc.is_alive():
-                    ti.proc.terminate()
+                kill_process_and_children(ti.proc.pid)
             return None, False
         tasks = new_results
         if cnt > 0 and cnt >= alow_processes_alive:
@@ -242,7 +257,7 @@ class Executor(object):
             target = config.target
             succ = target_executor(config)
         except Exception as e:
-            log.error(str(e))
+            traceback.print_exc()
             raise Exception(f"任务 {target} 执行失败")
         if succ:
             log.success(f"任务 {target} 执行成功")

lbkit-0.8.7/lbkit/tasks/image_maker/make_image.py

@@ -0,0 +1,17 @@
+"""环境准备"""
+import os
+from lbkit.tasks.config import Config
+from lbkit.tasks.task import Task
+
+
+class TaskMakeImage(Task):
+    def available(self):
+        return False
+
+    def run(self):
+        return
+
+if __name__ == "__main__":
+    config = Config()
+    build = TaskMakeImage(config, "test")
+    build.run()

lbkit-0.8.7/lbkit/tasks/image_maker/make_qemu_image.py

@@ -0,0 +1,75 @@
+"""环境准备"""
+import os
+import tempfile
+from lbkit.tasks.config import Config
+from lbkit.log import Logger
+from lbkit.utils.images.emmc import MakeImage as MekeEmmcImage
+from lbkit.tasks.image_maker.make_image import TaskMakeImage
+
+log = Logger("build_image")
+
+src_cwd = os.path.split(os.path.realpath(__file__))[0]
+
+class TaskMakeQemuImage(TaskMakeImage):
+    def __init__(self, config, name):
+        super().__init__(config, name)
+        self.chip_model = None
+        chip_model = self.config.get_product_config("chip_model")
+        if chip_model not in ["qemu_arm64"]:
+            return
+        self.chip_model = chip_model
+        self.uboot = self.config.get_product_config("flash/uboot")
+        self.kernel = self.config.get_product_config("flash/kernel")
+        self.rootfs = self.config.rootfs_img
+
+    @staticmethod
+    def _trans_to_blk_1m(cfg: str):
+        if cfg.endswith("K"):
+            return int(cfg[:-1]) / 1024
+        elif cfg.endswith("M"):
+            return int(cfg[:-1])
+        elif cfg.endswith("G"):
+            return int(cfg[:-1]) * 1024
+
+    def available(self):
+        if not self.chip_model:
+            return False
+        if self.config.get_product_config("flash/type") != "emmc":
+            return False
+        return True
+
+    def run(self):
+        """任务入口"""
+        """检查manifest文件是否满足schema格式描述"""
+        os.chdir(self.config.output_path)
+
+        mk = MekeEmmcImage(os.path.join(self.config.temp_path, "emmc_tmp_dir"))
+        rootfs_size = self.config.get_product_config("rootfs/size")
+        if rootfs_size:
+            mk.rootfs_blk_1m = self._trans_to_blk_1m(rootfs_size)
+        emmc_size = self.config.get_product_config("flash/size")
+        if emmc_size:
+            mk.size_1m = self._trans_to_blk_1m(emmc_size)
+        tmpdir = tempfile.TemporaryDirectory()
+        cmd = f"fuse2fs {self.rootfs} {tmpdir.name} -o fakeroot"
+        self.exec(cmd)
+        # 复制内核文件到boot/extlinux/Image
+        cmd = f"cp {self.kernel} {tmpdir.name}/boot/Image"
+        self.exec(cmd)
+        cmd = f"umount {tmpdir.name}"
+        self.exec(cmd)
+        mk.run(self.config.rootfs_img, "qemu.img")
+        cmd = 'cp /usr/share/litebmc/qemu.conf qemu.conf'
+        self.exec(cmd)
+        cmd = f'cp {self.uboot} u-boot.bin'
+        self.exec(cmd)
+        output_img = os.path.join(self.config.output_path, "litebmc_qemu.tar.gz")
+        cmd = f'tar -czf {output_img} -C . qemu.img u-boot.bin qemu.conf'
+        self.exec(cmd)
+        log.success(f"Create litebmc image {output_img} successfully")
+        return 0
+
+if __name__ == "__main__":
+    config = Config()
+    build = TaskMakeQemuImage(config, "test")
+    build.run()