精华内容
下载资源
问答
  • Android10-system.img-unpack EMUI10 MIUI12 Flyme8 firmware unpack. Android system.img unpack repack on Windows10. Android 8以上 ROM解包工具 文件说明: 1.brotli:解压工具,用于将「system.new.dat.br」...
  • windows平台下解包修改打包system.img和system.img.ext4工具 精品文档 精品文档 收集于网络如有侵权请联系管理员删除 收集于网络如有侵权请联系管理员删除 精品文档 收集于网络如有侵权请联系管理员删除 windows平台...
  • linux最小系统 (包括ramdisk-uboot.img system.img zImage) 适用于itop4412
  • simg2img 可以将android编译生成的system.img转换成raw img文件,查看android rom包的时候,不需要先刷机再去手机里看相应内容,直接就可以看rom包内文件。
  • 然后mkyaffs2image system system.img打包生成新的system.img,替换原来的system.img,并启动模拟器,效果图如下: 修改代码: 工具:odextools(参考:《一键odex批量合并工具odextools的重新整理与使用...
  • AndroidRom之system.img内容提取工具

    热门讨论 2013-05-06 15:18:59
    可用附件中的simg2img.exe来转化一下原始的system.img,然后再用其中的ext2Explorer来浏览提取system.img中的内容。 用法:1、将system.img改名为system.img.ext4。2、命令行cd到simg2img.exe目录下,执行命令“simg...
  • system.img解包工具

    2014-04-12 22:38:13
    解包system.img的一个工具 很好用 强大 EXT4 格式的
  • system.img 修改工具打包,方便其它机友。
  • linux下的system.img解压和打包工具
  • 目前越来越多的Android手机放弃了nand, 更多采用了emmc为内部存储设备。 以emmc为存储设备的android手机,其文件系统(/system,/data两个分区)一般采用ext4格式。...下面讲述如何解压和生成 system.img
  • 教你如何从线刷包里提取并解压system.img
  • 1、系统镜像(system.img) 系统镜像是地址ROM最常使用的一个镜像,用于存储Android系统的核心文件,System.img就是设备中system目录的镜像,里面包含了Android系统主要的目录和文件。一般这些文件是不允许修改的。...

    1、系统镜像(system.img)

    系统镜像是地址ROM最常使用的一个镜像,用于存储Android系统的核心文件,System.img就是设备中system目录的镜像,里面包含了Android系统主要的目录和文件。一般这些文件是不允许修改的。系统镜像对应的文件名一般叫system.img,当然,系统镜像的文件可以人以命名,之所以叫system.img,是为了与生成镜像文件之前的system目录保持一致,这样比较容易与其他类型的镜像文件区分。

    system.img可以添加

    1、Android系统应用,

    2、更多的library

    那么如何查看在system.img镜像中都有哪些内容呢,那么就需要我们解压

    尽管ROM中的5个镜像文件的扩展名都是img,但其格式却不同,也就是说不能使用同一种方法对其解压。

    对于system.img文件来说,可以使用unyafss命令对其解压。Android源代码中并未提供该命令,所以读者可以到

    http://code.google.com/p/unyaffs/downloads/list下载unyaffs的二进制程序和源代码,要注意,unyafss的二进制程序是Linux版本,如果要得到其他系统(windows和mac)的版本,需要在相应的系统上重新编译源代码。

    编译命令

    gcc -o unyaffs unyaffs.c

    unyaffs system.img

    如果对编译Android源代码生成的system.img文件执行上面的命令,可以完美的将system.img文件还原成system目录,会从system目录中看到相应的子目录,例如,/system/app、/system/lib等,实际上,system.img文件就是Android远吗/out/target/product/generic/system中的文件压缩生成的。不过很遗憾,对官方提供的system.img文件执行上面的命令并不能将system.img解压,所以可以初步判断官方提供的system.img的格式与有Android源代码生成的system.img文件格式不同。

    为了进一步验证system.img文件的格式,可以分别对官方提供的和由Android源代码生成的system.img文件执行如下的命令,并进行对比。

    file system.img

    我们发现不同,既然官方提供的system.img文件不能用unyaffs命令解压,那就使用另外一种方法。这种方法并不需要讲system.img解压,而是将系统镜像挂载(mount)到Linux的某个目录,实际上,这种方式比直接解压system.img文件更方便操作。

    注意:

    实际上,高版本Android的system.img通常是ext4格式的文件系统,而不是yaffs格式的文件系统,所以不能使用mkyaffs2image命令制作system.img,也不能使用unyaffs命令将其解压。如果想生成system.img文件,需要使用make_ext4命令,解压system.img需要使用mount命令将其挂载到某个目录.

    由于system.img是压缩格式,所以并不能直接使用mount命令挂载。在编译Android 源代码后会在Android源代码目录/out/host/linux-x86/bin目录生成一个simg2img命令行工具,建议将该目录加到PATH环境变量中,因为在本书中会大量使用bin目录中的各种命令行工具。

    simg2img可以通过如下的命令将system.img转化为普通的Linux镜像文件(system.img.raw)。

    simg2img system.img system.img.raw

    然后在/mnt目录中建立一个system子目录,并执行下面的 命令挂载系统镜像。

    mount system.img.raw /mnt/system

    执行文上面的命令后,进到/mnt/system目录,就会看到官方提供的系统镜像中所有文件,

    所有的目录都是可读写的。

    文件列表如下

    ===========================================================

    app目录:存放一般的apk文件。

    bin目录:存放一些Linux的工具,但是大部分都是toolbox的链接.

    etc目录:存放系统的配置文件。

    fonts目录:存放系统的字体文件。

    framework目录:存放系统平台所有jar包和资源文件包。

    lib目录:存放系统的共享库。

    media目录:存放系统的多媒体资源,主要是铃声。

    priv-app目录:android4.4开始新增加的目录,存放系统核心的apk文件。

    tts目录:存放系统的语言合成文件。

    usr目录:存放各种键盘布局,时间区域文件。

    vendor目录:存放一些第三方厂商的配置文件、firmware以及动态库。

    xbin目录:存放系统管理工具,这个文件夹的作用相当于标准Linux文件系统中的sbin.

    build.prop文件:系统属性的定义文件。

    ============================================================

    system.img.raw挂载到/mnt/system 目录后,该目录中的内容实际上与system.img中的内容完全一样,现在可以任意修改/mnt/system目录中的内容,例如,添加或替换/mnt/system/app 目录中的apk文件,或更换开机动画。在修改完系统镜像后,还需要使用make_extfs命令将/mnt/system目录重新生成system.img文件(EXT4文件系统)。

    make_ext4fs命令在如下的目录中,所以建议读者将该目录加到PATH环境变量中,这样的任意目录下都可以使用make_ext4fs命令。

    我们可以在Linux终端执行如下的命令生成system.img文件。

    make_ext4fs -s -l 1024M -a system system.img /mnt/system

    在执行make_ext4fs 命令使用了3个命令行参数,这些参数的含义如下:

    -s:生成Spare格式的镜像。这种格式的镜像文件的尺寸会更小,但无法直接使用mount命令挂载。要想挂载Spare格式的镜像文件,需要首先使用simg2img命令按着前面描述的方式进行转换。如果不加-s参数,生成的system.img文件是可以直接通过mount挂载。不过不管是不是Spare格式的系统镜像文件,Nexus 7都可以使用(其他的Android设备应该也可以),但建议生成Spare格式的镜像文件,因为这样的镜像文件尺寸更小。

    -l :  镜像的尺寸。该参数指定的值并不是生成镜像文件(r如system.img)的实际尺寸,而是文件系统的尺寸。这有些类似在Windows中建立的心得逻辑分区,而该参数指定的值就是逻辑分区的尺寸,生成的镜像文件的尺寸不能大于文件系统的尺寸。例如官方提供的用于Nexus 7的system.img文件(Spare格式的镜像文件)的尺寸大小越是480M,

    -a: 指定挂载点,这里是system.

    重新生成经过修改的system.img文件后,首先让Nexus 7 进入Bootloader模式,然后执行下面的命令即可刷机

    fastboot flash system system.img 

     

    用户镜像用来存储与用户相关的数据,一般对应的文件名是userdata.img(也可以是任何文件名,为了方便,我们将userdata称为用户镜像文件)。

    这些数据大多都是有用户在使用Android设备的过程中产生的,例如,通过Google play安装的第三方APK程序,用户的配置文件等。当然,在制作ROM时,也可以将部分数据放到userdata.img中。例如,如果允许用户使用普通的方法卸载ROM内置的应用,就可以将APK文件放到userdata.img文件中 (这里是普通的应用程序,而system.img放入的是系统应用程序)

    在学习userdata.img之前,首先应该了解userdata.img在整个Android系统中起到了什么作用。从前面的描述可以断定,userdata.img的作用之一就是将某些与用户相关的文件打包到ROM中,如果是APK程序,还允许卸载这些程序,除此之外,userdata.img还有另外一个作用,就是确定Android设备内存的大小。在Android

    设备中可供用户操作的存储区域通常有如下三部分。

    RAM   

    内存

    外出存储器(SD卡)

    RAM就是传统意义上的内存,与PC的内存是一个概念,只有在通电时吗才能存储数据,断点后所有数据将自动消失,所有要运行的程序都需要调用RAM。不过Android设备的内存就与RAM不一样了,这里的内存是指内部存储器。这一部分是大多数PC所有没有。因为现在所有的Android设备都有都带有一定大小的内部存储器(嵌入到芯片上,类似于内部嵌入一个SD卡),用于存储一些随机器发布的系统和应用程序。而PC除了RAM,就是硬盘了。一般PC在出厂时并不会将硬盘嵌入的芯片上,所以PC比Android设备少了一个内部存储器。

    最后一部分就是外部存储器,通常是SD卡。有的Android系统加入了OTG(On-The-Go)支持,所以通过OTG连接的U盘、移动硬盘也应属于外部存储器,有一些Android设备(如Nexus 7) 不支持插入SD卡。所以Android系统通过Linux 文件系统将内存划分成不同区域,例如,本节要讲的userdata.img就属于userdata分区,该分区就是前面所说

    的内存。而剩余的内存空间就会将其作为外部存储器。通常在Android设备的shell中可以通过/sdcard目录访问,从这些描述可以得出结论。userdata.mg的另一个作用就是确定Android设备内存的大小。如果Android设备支持外部存储器,内存的设置可以占用所有剩余的内部存储器(系统镜像、缓存区等部分也需要一定的存储空间)。如果Android设备不支持外部存储器,userdata.img就不能太大我,否则系统将无法利用剩余的空间映射SD卡(/sdcard,目录)

    userdata.img有如下两个功能:

     

    封装与用户相关的文件,并连同ROM一起发布,或单独刷userdata.img文件。

    确定Android设备内存的大小。

     

    2、用户数据镜像(userdata.img)

     

    学习userdata.img的第一步就是解剖他。方法与解剖system类似.

    首先需要使用simg2img命令将userdata.img文件还原成非压缩格式的镜像文件,这样可以直接使用mount命令将userdata.img文件挂载到某个目录,进而查看userdata.img中的内容。可以使用前面章节编译官方Android源代码或CM Android源代码生成userdata.img文件做这个实验,也可以使用官方发布的Nexus系列ROM中的userdata.img文件做这个实验。还原userdata.img的命令如下:

    simg2img userdata.img userdata.img.raw

    执行上面的命令后,会生成还原后的userdata.img.raw文件。然后使用下面的命令挂载userdata.img.raw文件。

    mkdir -p /mnt/rom/userdata

    mount  userdata.img.raw /mnt/rom/userdata

    如果挂载成功,会在/mnt/rom/userdata 目录看到userdata.img 中的内容。通常该目录除了“lost+found”(该目录一般为空,在系统非法关机时会存放一些文件) 系统目录外,什么都没有。读者可以执行下面的命令查看当前挂载的用户镜像尺寸。,

    df -h

    现在可以在/mnt/rom/userdata目录放一些目录或文件,例如,将Test.apk作为普通的Android应用放入userdata.img,如要在/mnt/rom/userdata目录建立一个app子目录,然后将Test.apk文件放入app目录即可。

    在修改完/mnt/roim/userdata目录后,需要使用下面的命令重新打包/mnt/rom/userdata 目录。为了与userdata.img区别即可。

    在修改完/mnt/rom/userdata目录后,需要使用下面的命令重新打包/mnt/rom/userdata目录,为了与userdata.img区别,在这里将该目录打包成了userdata.img.new。 要注意,在打包的过程中会确定用户镜像对应的空间大小,例如,下面的命令生成了最大为128M的用户镜像文件(userdata.img.new,ext4格式的镜像文件)。

    make_ext4fs -s -l 128M -a data userdata.img.new /mnt/rom/userdata

    要注意的是,加上"-s"命令行,参数就表示生成的userdata.img.new 文件是压缩格式,不能直接使用mount命令挂载,需要按着签名的而方法通过simg2img命令来还原才能挂载到某一目录。“-a”命令行参数后面的是文件系统,这里需要制定data。

    接下来可以使用下面的命令将userdata.img.new 文件刷到Android设备上(加上目录Android设备正处于正常的启动状态,并通过USB线PC相连)。注意:在刷userdata.img.new文件之前,一定 要备份Android设备上已安装的应用程序、配置和其他数据,否则这些数据将全部丢失(SD卡中的数据不会丢失)。

    adb reboot bootloader

    fastboot flash userdata userdata.img.new

    fastboot reboot

    上面的命令在刷完userdata.img.new 后,会重启Android设备。在进行一些设置后(因为以前的配置都丢失了),会重新进入Home界面。然后通过“设置”》"存储"可以查看使用情况,

    make_ext4fs -s -l 1G -a data userdata.img.new /mnt/rom/userdata

    注意:

    用户镜像占用的存储空间不能超过Android设备的内部存储器的总尺寸,否则即使成功刷机,Android设备也可能会启不来,即使启来也由于SD卡无法挂载而出现如图4-10所示的界面,要求输入密码(实际上就是映射失败)。

     

     

    3、内存磁盘镜像(ramdisk.img

    内存磁盘镜像存储了Linux内核启动时要装载的核心文件,通常的镜像文件名为ramdisk.img.尽管ramdisk.img需要放在Linux内核镜像(boot.img)中,但却属于Android源代码的一部分。也就是说,在编译Android 源代码后,会生成一个ramdisk.img文件,其实该文件就是root目录压缩后生成的文件。ramdisk.img文件中封装的内容是Linux内核与Android系统杰出的第一批文件,其中有一个非常重要的init命令(在root目录中可以找到该命名文件),该命令用于读取init.rc以及相关配置文件中的初始化命令。之所以称ramdisk.img为内存磁盘镜像,是因为ramdisk.img中的文件映射的实际上都是内存中的文件,也就是说,即使有权修改init.rc等文件,也只是修改原始文件在内存中的镜像,重新启动Android设备后,有会恢复到最初的状态。而修改这些文件的唯一方法就是重新制作ramdisk.img文件,并连同Linux内核二进制文件(ZImage)生成boot.img文件,并且在Bootloader模式刷机才可以。而ramdisk.img是boot.img中重要的组成部分之一,

    ramdisk.img文件与前面介绍的system.img、userdata.img不一样,不能使用simg2img还原,并使用mount挂载。其实ramdisk.img文件只是一个普通的zip压缩文件,可以直接使用gunzip命令解压,不过解压后并不是原声文件和目录,而是有cpio命令备份的文件,所以还需要使用cpio继续还原。

    假设ramdisk.img文件在当前目录下,则还原ramdisk.img文件的命令如下:

    mkdir ramdisk

    cp ramdisk 

    gunzip -c ../ramdisk.img > ../ramdisk.cpio

    cpio -i < ../ramdisk.cpio

    也可以将最后两行命令合成如下的一行。

    gunzip -c ../ramdisk.img | cpio -i

    执行上面的命令后,就会在ramdisk目录中看到内存磁盘镜像还原后的目录结构,

    如果现在要修改init.rc等配置文件,可以自己在ramdisk目录中找到相应的文件并修改。例如,有Linux的瑞士军刀之称busybox,可以放到ramdisk中的sbin目录下。这样在Recovery模式下就可以使用busybox命令完成很多操作了。

    修改完ramdisk目录的内容后,就需要使用下面的命令将ramdisk目录重新生成ramdisk.img文件。为了与原来的ramdisk.img文件有所区别,这里生成了ramdisk.img.new文件,在执行下面的命令之前,要保证Linux终端的当前目录是ramdisk。

    mkbootfs . | minigzip > ../ramdisk.img.new

     

    4、Linux内核镜像(boot.img)

    Linux内核镜像包含了内核二进制(zImage)和内存磁盘镜像(ramdisk.img),一般对应的镜像文件是boot.img(也可以是任何其他的名字)。由于ramdisk.img中包含的init命令是与Linux内核第一个交互的程序,所以在boot.img中需要同时包含Linux内核(zImage)和ramdisk.img。当Linux内核调用init后,系统就会根据init.rc及其相关文件的代码对整个Android系统进行初始化。其中主要的初始化工作就是建立如/system、/data、等系统目录,然后使用mount命令将相应的镜像挂载到这些目录上。

    Android源代码经过编译后,也可以在其中找到对boot.img解压和生成boot.img文件的命令。

    其中unpackbooting 为解压命令,mkbooting命令可以将zImage和ramdisk.img文件合并成boot.img。下面先来用unpackbooting命令将boot.img解压,再看看boot.img是不是有zImage和ramdisk.img文件组成的。

    假设boot.img文件(我们可以使用从其他Rom压缩包中获得的boot.img,也可以使用通过Android源代码生成的boot.img)在当前目录中,使用下面的命令可以将boot.img文件解压到boot目录中。

    mkdir boot

    cd boot 

    unpackbootimg -i  ../boot.img

     

    执行完上面的命令后,会发现boot目录中多了几个文件,其中有两个主要的文件:

    boot.img-zImage 和boot.img-ramdisk.gz。前者是Linux 内核文件(与zImage文件完全一样),后者是内存磁盘镜像(与ramdisk.img完全一样)。为了证明boot.img-ramdisk.gz 与ramdisk.img文件完全相等,可以使用下面的命令将boot.img-ramdisk.gz 解压到ramdisk目录。

    mkdir ramdisk

    cd ramdisk

    gunzip -c ../boot.img-ramdisk.gz | cpio  -i

    目录结构与ramdisk.img 一样

    、如果想向init.rc或娶她文件中添加新的内容,或在内存磁盘镜像中添加新的命令,可以修改刚才由boot.img-ramdisk.gz 文件解压生成的ramdisk目录中的相应文件和目录的内容,然后使用下面的命令重新将ramdisk目录中的相应文件和目录的内容,然后使用下面的命令重新将ramdisk打包成boot.img-ramdisk.gz.new(当前目录是ramdisk)。

    mkbootfs . " minigzip > ../boot.img-ramdisk.gz.new

    接下来推到上一层目录,然后使用下面的命令将boot.img-zImage 和boot.img-ramdisk.gz.new

    文件合并成boot.img.new 文件(为了区分boot.img,这里生成了boot.img.new 文件)。

    mkbootimg --kernel boot.img-zImage --ramdisk boot.img-ramdisk.gz.new -o boot.img.new

    如果想修改Linux内核,需要下载Linux内核源代码(官方和CM都提供了相应Android设备的Linux内核源代码)

    接下来退到上一层目录,然后使用下面的命令将boot.img-zImage  和boot.img-ramdisk.gz.new

    现在可以使用下面的命令重新刷Linux内核(加上Android系统处于正常启动状态,并通过USB线和PC相连)。不过要注意的是Linux内核必须与当前Android设备匹配,否则刷完后Android设备有可能起不来。刷Linux内核不会对系统(system.img)和用户数据(userdata.img)造成任何影响。

    adb reboot bootloader

    fastboot flash boot boot.img,new 

    fastboot reboot

    重启Android设备后,如果我们修改了Linux内核和内存磁盘镜像,就会立刻生效

    注意:

    (boot.img解压后,除了生成boot.img-zImage和boot.img-ramdisk.gz文件外,还会生成一些其他的文件,如boot.img-base、boot.img-cmdline、boot.img-pagesize等,这些文件都是一些配置文件。例如,boot.img-cmdline文件中包含了Linux内核启动时传入的参数。通常并不需要管这些文件,只需要保持默认值即可)。

     

     

     

    5、5Recovery镜像(recovery.img


    Recovery镜像只用于刷机,通常的镜像文件名为:receovery.img,其实制作ROM并不一定要制作Recovery镜像。因为有很多现成好用的Recovery,例如,Clockworkmod Recovery就是其咋红的佼佼者。尽管有很多Recovery可以同不过有时由于特殊的需要或显示自己更加geek。想定制自己的Recovery。本节将详细介绍如何定制recovery.img,不过事先说明一点,定制recovery.img的方法只是在已经有recovery镜像文件的前提下完成的。关于如何更深入定制recovery和修改recovery的源代码。

    在学习定制Recovery.img之前,先清除recovery.img到底是个什么东西。从本质上说,recovery.img和boot.img高达90%是一样的。这就意味着,recovery.img也是Linux内核(zImage)和内存磁盘镜像(ramdisk.img)组成的。这两个镜像中的Linux内核是完全一样的,区别只是ramdisk.img中的少部分文件存在差异。其中最主要的差异是recovery.img和ramdisk.img中的sbin目录中多了一个recovery命令进入Recovery主界面,而不会正常启动Android系统。实现的原理是Recovery.img和boot.img在自己的分区各自有一个Linux内核(zImage),尽管Linux内核都一样,但Linux内核调用的init命令解析的init.rc及其相关文件的内容有一定的差异。而Bootloader根据用户的选择决定使用boot.img中Linux内核,还是使用Recovery.img中的Linux内核启动系统。如果使用前者,Android系统就会正常启动,如果使用后者,就会进入Recovery选择菜单,所以recovery.img和boot.img的第二个差异就是其中的init.rc及其相关配置文件的内容略有不同。

    从前面的描述还可以看出,recovery.img和boot.img其实都是一个最小的运行系统,也就是说他们都各自带一个满足最低要求的运行环境(ramdisk.img)。boot.img利用这个运行环境监理更大的运行环境(system.img) ,而recovery.img就直接使用了这个运行环境进行基本的操作(复制文件、删除文件、加压文件、mount等),这些操作也就是Recovery模式下刷机要进行的一些操作。

    既然了解了recovery.img是什么东西,那么就可以解压recovery.img,并且重写生成recovery.img文件。

    假设recovery.img文件在当前目录下,具体的解压和打包命令如下。

    解压recovery.img

    mkdir recovery

    cd recovery

    uppackbootimg -i ../recovery.img

    执行下面的命令会在recovery目录下生成如下5个文件。

    recovery.img-zImage

    recovery.img-ramdisk.gz

    recovery.img-cmdline

    recovery.img-pagesize

    recovery.img-base

    其中前两个分别为recovery.img中的Linux内核和内存磁盘镜像。可以使用下面的命令解压recovery.img-ramdisk.gz文件。

    解压recovery.img-ramdisk.gz文件

    mkdir ramdisk

    cd ramdisk

    gunzip -c ../recovery.img-ramdisk.gz | cpio -i

    现在回到上一层目录,最后按着4.2.4小节的方法重新生成内存镜像文件(这里为Recovery.img-randisk.gz.new),并使用下面的命令重新生成Recovery镜像(这里为recovery.img.new )。

    重新生成Recovery镜像文件

    mkbootimg --kernel recovery.img-zImage --ramdisk recovery.img-ramdisk.gz.new -o recovery.img.new

    现在可以使用下面的命令重新刷Recovery(加上Android 处在正常启动状态),并进入Recovery模式。

    Recovery镜像

    adb reboot bootloader

    fastboot flash recovery recovery.img.new

    fastboot reboot

    adb reboot recovery

    6、缓存镜像(cache.img

    缓存镜像用于存储系统或用户应用产生的临时数据,通常的镜像文件名为chche.img。一般ROM并不需要包含缓存镜像,不过在这里还是介绍一下如何制作和刷缓存镜像。

    缓存镜像实际上就是一个空的ext4格式的文件系统镜像,可以使用下面的命令生成缓存镜像。

    mkdir -p /mnt/rom/cache

    make_ext4fs -s -l 256M -a cache cache.img /mnt/rom/cache

    可以使用下面的命令刷缓存镜像。

    adb reboot bootloader

    fastboot flash cache cache.img

    fastboot reboot

     



    展开全文
  • 解包system.img工具

    2013-06-08 16:05:22
    只要点击机器人文件,将system.img导入 马上就解包出你所需要的文件
  • system.img 解压

    2017-12-28 15:35:44
    system.img 解压system.img 解压system.img 解压system.img 解压system.img 解压system.img 解压
  • android system.img解包工具(windows)版

    千次下载 热门讨论 2011-05-27 17:14:24
    把unyaffs与system.img放到同一目录,进入命令模式,运行:unyaffs system.img;windows上的android img解包工具,用于解system.img等文件,不包含打包功能。
  • System.img是如何打包的

    千次阅读 2019-07-13 15:42:21
    当敲击make命令时,会找到第一个目标droid(在build/core/main.mk中),droid依赖droid_targets,droid_targets依赖droidcore和dist_files,droidcore的依赖关系如下:... systemimage \ $(INSTALLED_BOOTIMAGE_TAR...

    ★★★ 友情链接 : 个人博客导读首页—点击此处 ★★★

    当敲击make命令时,会找到第一个目标droid(在build/core/main.mk中),droid依赖droid_targets,droid_targets依赖droidcore和dist_files,droidcore的依赖关系如下:

    .PHONY: droidcore
    droidcore: files \
    	systemimage \
    	$(INSTALLED_BOOTIMAGE_TARGET) \
    	$(INSTALLED_RECOVERYIMAGE_TARGET) \
    	$(INSTALLED_VBMETAIMAGE_TARGET) \
    	$(INSTALLED_USERDATAIMAGE_TARGET) \
    	$(INSTALLED_CACHEIMAGE_TARGET) \
    	$(INSTALLED_BPTIMAGE_TARGET) \
    	$(INSTALLED_VENDORIMAGE_TARGET) \
    	$(INSTALLED_PRODUCTIMAGE_TARGET) \
    	$(INSTALLED_SYSTEMOTHERIMAGE_TARGET) \
    	$(INSTALLED_FILES_FILE) \
    	$(INSTALLED_FILES_FILE_VENDOR) \
    	$(INSTALLED_FILES_FILE_PRODUCT) \
    	$(INSTALLED_FILES_FILE_SYSTEMOTHER) \
    	soong_docs
    

    切到build/core/Makefile中,我们看到systemimage又依赖INSTALLED_SYSTEMIMAGE,而INSTALLED_SYSTEMIMAGE又依赖BUILT_SYSTEMIMAGE,BUILT_SYSTEMIMAGE其实就是system.img

    systemimage: $(INSTALLED_SYSTEMIMAGE)
    $(INSTALLED_SYSTEMIMAGE): $(BUILT_SYSTEMIMAGE) $(RECOVERY_FROM_BOOT_PATCH)
    
    BUILT_SYSTEMIMAGE := $(systemimage_intermediates)/system.img
    

    我们再来看看BUILT_SYSTEMIMAGE的依赖关系:

    $(BUILT_SYSTEMIMAGE): $(FULL_SYSTEMIMAGE_DEPS) $(INSTALLED_FILES_FILE) $(BUILD_IMAGE_SRCS)
    	$(call build-systemimage-target,$@)
    

    BUILT_SYSTEMIMAGE依赖的一些文件生成后,会调用makefile中的build-systemimage-target函数,我们接着去看build-systemimage-target的函数原型:

    define build-systemimage-target
      @echo "Target system fs image: $(1)"
      $(call create-system-vendor-symlink)
      @mkdir -p $(dir $(1)) $(systemimage_intermediates) && rm -rf $(systemimage_intermediates)/system_image_info.txt
      $(call generate-userimage-prop-dictionary, $(systemimage_intermediates)/system_image_info.txt, \
          skip_fsck=true)
      $(hide) PATH=$(foreach p,$(INTERNAL_USERIMAGES_BINARY_PATHS),$(p):)$$PATH \
          ./build/tools/releasetools/build_image.py \
          $(TARGET_OUT) $(systemimage_intermediates)/system_image_info.txt $(1) $(TARGET_OUT) \
          || ( echo "Out of space? the tree size of $(TARGET_OUT) is (MB): " 1>&2 ;\
               du -sm $(TARGET_OUT) 1>&2;\
               if [ "$(INTERNAL_USERIMAGES_EXT_VARIANT)" == "ext4" ]; then \
                   maxsize=$(BOARD_SYSTEMIMAGE_PARTITION_SIZE); \
                   if [ "$(BOARD_HAS_EXT4_RESERVED_BLOCKS)" == "true" ]; then \
                       maxsize=$$((maxsize - 4096 * 4096)); \
                   fi; \
                   echo "The max is $$(( maxsize / 1048576 )) MB." 1>&2 ;\
               else \
                   echo "The max is $$(( $(BOARD_SYSTEMIMAGE_PARTITION_SIZE) / 1048576 )) MB." 1>&2 ;\
               fi; \
               mkdir -p $(DIST_DIR); cp $(INSTALLED_FILES_FILE) $(DIST_DIR)/installed-files-rescued.txt; \
               exit 1 )
    endef
    

    看起来挺复杂吧,其实都是些shell语句,仔细看还是能看懂的。看不懂也没关系,我们只关心其中的关键语句 ./build/tools/releasetools/build_image.py,其后跟随了一堆的参数,我们不必关心这些参数,只要 明白,这里调用了build_image.py
    打开build_image.py,main函数如下,其实并不复杂,这里随后调用了BuildImage()

    def main(argv):
      if len(argv) != 4:
        print __doc__
        sys.exit(1)
    
      in_dir = argv[0]
      glob_dict_file = argv[1]
      out_file = argv[2]
      target_out = argv[3]
    
      glob_dict = LoadGlobalDict(glob_dict_file)
      if "mount_point" in glob_dict:
        # The caller knows the mount point and provides a dictionay needed by
        # BuildImage().
        image_properties = glob_dict
      else:
        image_filename = os.path.basename(out_file)
        mount_point = ""
        if image_filename == "system.img":
          mount_point = "system"
        elif image_filename == "system_other.img":
          mount_point = "system_other"
        elif image_filename == "userdata.img":
          mount_point = "data"
        elif image_filename == "cache.img":
          mount_point = "cache"
        elif image_filename == "vendor.img":
          mount_point = "vendor"
        elif image_filename == "oem.img":
          mount_point = "oem"
        else:
          print >> sys.stderr, "error: unknown image file name ", image_filename
          exit(1)
    
        image_properties = ImagePropFromGlobalDict(glob_dict, mount_point)
    
      if not BuildImage(in_dir, image_properties, out_file, target_out):
        print >> sys.stderr, "error: failed to build %s from %s" % (out_file,
                                                                    in_dir)
        exit(1)
    

    继续查看BuildImage(),原型如下:

    def BuildImage(in_dir, prop_dict, out_file, target_out=None):
      """Build an image to out_file from in_dir with property prop_dict.
    
      Args:
        in_dir: path of input directory.
        prop_dict: property dictionary.
        out_file: path of the output image file.
        target_out: path of the product out directory to read device specific FS config files.
    
      Returns:
        True iff the image is built successfully.
      """
      # system_root_image=true: build a system.img that combines the contents of
      # /system and the ramdisk, and can be mounted at the root of the file system.
      origin_in = in_dir
      fs_config = prop_dict.get("fs_config")
      base_fs_file = None
      if (prop_dict.get("system_root_image") == "true"
          and prop_dict["mount_point"] == "system"):
        in_dir = tempfile.mkdtemp()
        # Change the mount point to "/"
        prop_dict["mount_point"] = "/"
        if fs_config:
          # We need to merge the fs_config files of system and ramdisk.
          fd, merged_fs_config = tempfile.mkstemp(prefix="root_fs_config",
                                                  suffix=".txt")
          os.close(fd)
          with open(merged_fs_config, "w") as fw:
            if "ramdisk_fs_config" in prop_dict:
              with open(prop_dict["ramdisk_fs_config"]) as fr:
                fw.writelines(fr.readlines())
            with open(fs_config) as fr:
              fw.writelines(fr.readlines())
          fs_config = merged_fs_config
    
      build_command = []
      fs_type = prop_dict.get("fs_type", "")
      run_fsck = False
    
      fs_spans_partition = True
      if fs_type.startswith("squash"):
        fs_spans_partition = False
    
      is_verity_partition = "verity_block_device" in prop_dict
      verity_supported = prop_dict.get("verity") == "true"
      verity_fec_supported = prop_dict.get("verity_fec") == "true"
    
      # Adjust the partition size to make room for the hashes if this is to be
      # verified.
      if verity_supported and is_verity_partition:
        partition_size = int(prop_dict.get("partition_size"))
        (adjusted_size, verity_size) = AdjustPartitionSizeForVerity(partition_size,
                                                                    verity_fec_supported)
        if not adjusted_size:
          return False
        prop_dict["partition_size"] = str(adjusted_size)
        prop_dict["original_partition_size"] = str(partition_size)
        prop_dict["verity_size"] = str(verity_size)
    
      # Adjust partition size for AVB hash footer or AVB hashtree footer.
      avb_footer_type = ''
      if prop_dict.get("avb_hash_enable") == "true":
        avb_footer_type = 'hash'
      elif prop_dict.get("avb_hashtree_enable") == "true":
        avb_footer_type = 'hashtree'
    
      if avb_footer_type:
        avbtool = prop_dict["avb_avbtool"]
        partition_size = prop_dict["partition_size"]
        # avb_add_hash_footer_args or avb_add_hashtree_footer_args.
        additional_args = prop_dict["avb_add_" + avb_footer_type + "_footer_args"]
        max_image_size = AVBCalcMaxImageSize(avbtool, avb_footer_type, partition_size,
                                             additional_args)
        if max_image_size == 0:
          return False
        prop_dict["partition_size"] = str(max_image_size)
        prop_dict["original_partition_size"] = partition_size
    
      if fs_type.startswith("ext"):
        build_command = [prop_dict["ext_mkuserimg"]]
        if "extfs_sparse_flag" in prop_dict:
          build_command.append(prop_dict["extfs_sparse_flag"])
          run_fsck = True
        build_command.extend([in_dir, out_file, fs_type,
                              prop_dict["mount_point"]])
        build_command.append(prop_dict["partition_size"])
        if "journal_size" in prop_dict:
          build_command.extend(["-j", prop_dict["journal_size"]])
        if "timestamp" in prop_dict:
          build_command.extend(["-T", str(prop_dict["timestamp"])])
        if fs_config:
          build_command.extend(["-C", fs_config])
        if target_out:
          build_command.extend(["-D", target_out])
        if "block_list" in prop_dict:
          build_command.extend(["-B", prop_dict["block_list"]])
        if "base_fs_file" in prop_dict:
          base_fs_file = ConvertBlockMapToBaseFs(prop_dict["base_fs_file"])
          if base_fs_file is None:
            return False
          build_command.extend(["-d", base_fs_file])
        build_command.extend(["-L", prop_dict["mount_point"]])
        if "extfs_inode_count" in prop_dict:
          build_command.extend(["-i", prop_dict["extfs_inode_count"]])
        if "flash_erase_block_size" in prop_dict:
          build_command.extend(["-e", prop_dict["flash_erase_block_size"]])
        if "flash_logical_block_size" in prop_dict:
          build_command.extend(["-o", prop_dict["flash_logical_block_size"]])
        # Specify UUID and hash_seed if using mke2fs.
        if prop_dict["ext_mkuserimg"] == "mkuserimg_mke2fs.sh":
          if "uuid" in prop_dict:
            build_command.extend(["-U", prop_dict["uuid"]])
          if "hash_seed" in prop_dict:
            build_command.extend(["-S", prop_dict["hash_seed"]])
        if "selinux_fc" in prop_dict:
          build_command.append(prop_dict["selinux_fc"])
      elif fs_type.startswith("squash"):
        build_command = ["mksquashfsimage.sh"]
        build_command.extend([in_dir, out_file])
        if "squashfs_sparse_flag" in prop_dict:
          build_command.extend([prop_dict["squashfs_sparse_flag"]])
        build_command.extend(["-m", prop_dict["mount_point"]])
        if target_out:
          build_command.extend(["-d", target_out])
        if fs_config:
          build_command.extend(["-C", fs_config])
        if "selinux_fc" in prop_dict:
          build_command.extend(["-c", prop_dict["selinux_fc"]])
        if "block_list" in prop_dict:
          build_command.extend(["-B", prop_dict["block_list"]])
        if "squashfs_compressor" in prop_dict:
          build_command.extend(["-z", prop_dict["squashfs_compressor"]])
        if "squashfs_compressor_opt" in prop_dict:
          build_command.extend(["-zo", prop_dict["squashfs_compressor_opt"]])
        if "squashfs_block_size" in prop_dict:
          build_command.extend(["-b", prop_dict["squashfs_block_size"]])
        if "squashfs_disable_4k_align" in prop_dict and prop_dict.get("squashfs_disable_4k_align") == "true":
          build_command.extend(["-a"])
      elif fs_type.startswith("f2fs"):
        build_command = ["mkf2fsuserimg.sh"]
        build_command.extend([out_file, prop_dict["partition_size"]])
      else:
        print("Error: unknown filesystem type '%s'" % (fs_type))
        return False
    
      if in_dir != origin_in:
        # Construct a staging directory of the root file system.
        ramdisk_dir = prop_dict.get("ramdisk_dir")
        if ramdisk_dir:
          shutil.rmtree(in_dir)
          shutil.copytree(ramdisk_dir, in_dir, symlinks=True)
        staging_system = os.path.join(in_dir, "system")
        shutil.rmtree(staging_system, ignore_errors=True)
        shutil.copytree(origin_in, staging_system, symlinks=True)
    
      has_reserved_blocks = prop_dict.get("has_ext4_reserved_blocks") == "true"
      ext4fs_output = None
    
      try:
        if fs_type.startswith("ext4"):
          (ext4fs_output, exit_code) = RunCommand(build_command)
        else:
          (_, exit_code) = RunCommand(build_command)
      finally:
        if in_dir != origin_in:
          # Clean up temporary directories and files.
          shutil.rmtree(in_dir, ignore_errors=True)
          if fs_config:
            os.remove(fs_config)
        if base_fs_file is not None:
          os.remove(base_fs_file)
      if exit_code != 0:
        return False
    
      # Bug: 21522719, 22023465
      # There are some reserved blocks on ext4 FS (lesser of 4096 blocks and 2%).
      # We need to deduct those blocks from the available space, since they are
      # not writable even with root privilege. It only affects devices using
      # file-based OTA and a kernel version of 3.10 or greater (currently just
      # sprout).
      # Separately, check if there's enough headroom space available. This is useful for
      # devices with low disk space that have system image variation between builds.
      if (has_reserved_blocks or "partition_headroom" in prop_dict) and fs_type.startswith("ext4"):
        assert ext4fs_output is not None
        ext4fs_stats = re.compile(
            r'Created filesystem with .* (?P<used_blocks>[0-9]+)/'
            r'(?P<total_blocks>[0-9]+) blocks')
        m = ext4fs_stats.match(ext4fs_output.strip().split('\n')[-1])
        used_blocks = int(m.groupdict().get('used_blocks'))
        total_blocks = int(m.groupdict().get('total_blocks'))
        reserved_blocks = 0
        headroom_blocks = 0
        adjusted_blocks = total_blocks
        if has_reserved_blocks:
          reserved_blocks = min(4096, int(total_blocks * 0.02))
          adjusted_blocks -= reserved_blocks
        if "partition_headroom" in prop_dict:
          headroom_blocks = int(prop_dict.get('partition_headroom')) / BLOCK_SIZE
          adjusted_blocks -= headroom_blocks
        if used_blocks > adjusted_blocks:
          mount_point = prop_dict.get("mount_point")
          print("Error: Not enough room on %s (total: %d blocks, used: %d blocks, "
                "reserved: %d blocks, headroom: %d blocks, available: %d blocks)" % (
                    mount_point, total_blocks, used_blocks, reserved_blocks,
                    headroom_blocks, adjusted_blocks))
          return False
    
      if not fs_spans_partition:
        mount_point = prop_dict.get("mount_point")
        partition_size = int(prop_dict.get("partition_size"))
        image_size = GetSimgSize(out_file)
        if image_size > partition_size:
          print("Error: %s image size of %d is larger than partition size of "
                "%d" % (mount_point, image_size, partition_size))
          return False
        if verity_supported and is_verity_partition:
          ZeroPadSimg(out_file, partition_size - image_size)
    
      # create the verified image if this is to be verified
      if verity_supported and is_verity_partition:
        if not MakeVerityEnabledImage(out_file, verity_fec_supported, prop_dict):
          return False
    
      # Add AVB HASH or HASHTREE footer (metadata).
      if avb_footer_type:
        avbtool = prop_dict["avb_avbtool"]
        original_partition_size = prop_dict["original_partition_size"]
        partition_name = prop_dict["partition_name"]
        # key_path and algorithm are only available when chain partition is used.
        key_path = prop_dict.get("avb_key_path")
        algorithm = prop_dict.get("avb_algorithm")
        salt = prop_dict.get("avb_salt")
        # avb_add_hash_footer_args or avb_add_hashtree_footer_args
        additional_args = prop_dict["avb_add_" + avb_footer_type + "_footer_args"]
        if not AVBAddFooter(out_file, avbtool, avb_footer_type, original_partition_size,
                            partition_name, key_path, algorithm, salt, additional_args):
          return False
    
      if run_fsck and prop_dict.get("skip_fsck") != "true":
        success, unsparse_image = UnsparseImage(out_file, replace=False)
        if not success:
          return False
    
        # Run e2fsck on the inflated image file
        e2fsck_command = ["e2fsck", "-f", "-n", unsparse_image]
        (_, exit_code) = RunCommand(e2fsck_command)
    
        os.remove(unsparse_image)
    
      return exit_code == 0
    

    这里面有一堆的参数,其实都非常有深意后,我们在学习阶段可以不必考虑,当我们遇到相关问题时,那时可能就会对照这些参数,了解其功能和作用。 而我们这里重点查看的,如下:

     if prop_dict["ext_mkuserimg"] == "mkuserimg_mke2fs.sh":
          if "uuid" in prop_dict:
            build_command.extend(["-U", prop_dict["uuid"]])
          if "hash_seed" in prop_dict:
            build_command.extend(["-S", prop_dict["hash_seed"]])
    

    这里是执行了mkuserimg_mke2fs.sh脚本,我们再去看看这个脚本吧
    路径:system/extras/ext4_utils/mkuserimg_mke2fs.sh
    同样,打开该文件后发现又是一堆的参数命令,看也看不懂,我们依然只是关心其核心的部分,截取如下:

    MAKE_EXT4FS_CMD="mke2fs $MKE2FS_OPTS -t $EXT_VARIANT -b $BLOCKSIZE $OUTPUT_FILE $SIZE"
    echo $MAKE_EXT4FS_ENV $MAKE_EXT4FS_CMD
    env $MAKE_EXT4FS_ENV $MAKE_EXT4FS_CMD
    if [ $? -ne 0 ]; then
      exit 4
    fi
    
    if [[ $E2FSPROGS_FAKE_TIME ]]; then
      E2FSDROID_ENV="E2FSPROGS_FAKE_TIME=$E2FSPROGS_FAKE_TIME"
    fi
    
    E2FSDROID_CMD="e2fsdroid $E2FSDROID_OPTS -f $SRC_DIR -a $MOUNT_POINT $OUTPUT_FILE"
    echo $E2FSDROID_ENV $E2FSDROID_CMD
    env $E2FSDROID_ENV $E2FSDROID_CMD
    if [ $? -ne 0 ]; then
      rm -f $OUTPUT_FILE
      exit 4
    fi
    

    这里做了两件事:
    (1)mke2fs打包生成了system.img
    (2)e2fsdroid制作了system.map
    mke2fs对应的源码:external/e2fsprogs/misc/mke2fs.c
    e2fsdroid对应的源码 : external/e2fsprogs/contrib/android/e2fsdroid.c

    深思:
    其实呢,在正常的android编译,并不会生成system.map,因为最后一个参数$OUTPUT_FILE为空. 在android的设计中system.map是在制作OTA的target-files文件时生成的,然后在制作block差分别时候,会用到system.map,一个block一个block的去求diff。
    在制作OTA的target-files时,会重新打包system.img,其流程:
    add_img_to_target_files直接调用了build_image.py中的CreateImage()函数,与正常的打包system.img参数稍微不同,这里增加了一个block_list="system.map"参数,所以其打包结束后,生成了system.map

    Q & A:
    1、system.img是怎样制作的?
    答:使用mke2fs工具制作的
    2、system.map是做什么用的?先有的system.img,还是先用的system.map?
    答:system.map是制作OTA的target-files文件时,重新打包system.img后,根据system.img做出的system.map,制作差分别时候,会用到system.map文件

    不足之处,欢迎指正!

    展开全文
  • img2sdat.py#!/usr/bin/env python#coding=utf-8import sysif sys.hexversion &lt; 0x02070000: print &gt;&gt; sys.stderr, "Python 2.7 or newer is required." sy...
    android 8.1上面验证,支持所有的android版本,直接放到sdk中执行即可。

    img2sdat.py
    #!/usr/bin/env python
    #coding=utf-8

    import sys

    if sys.hexversion < 0x02070000:
      print >> sys.stderr, "Python 2.7 or newer is required."
      sys.exit(1)

    from hashlib import sha1 as sha1

    import common
    import sparse_img

    OPTIONS = common.OPTIONS

    try:
        PARTITION_NAME = str(sys.argv[1])
        SYSTEM_IMG = str(sys.argv[2])
        OUTPUT_DIR = str(sys.argv[3])
        OPTIONS.outpath = OUTPUT_DIR
    except IndexError:
        print('\nUsage: img2sdat.py <partiton_name> <system_img> <system_new_dir>\n')
        print('  eg:   img2sdat.py system system.img system_new\n')
        print('        <partiton_name>: input partition name')
        print('        <img_name>: input image name')
        print('        <new_dir>: image new dat dir')
        print('        Visit xda thread for more information.\n')
        try:
           input = raw_input
        except NameError: pass
        input('Press ENTER to exit...')
        sys.exit()


    def main(argv):  
      system_tgt = sparse_img.SparseImage(SYSTEM_IMG);
      system_tgt.ResetFileMap()
      system_diff = common.BlockDifference(PARTITION_NAME, system_tgt, src=None, check_first_block=False, version=4)


    if __name__ == '__main__':  
      main(sys.argv[1:])  
    目前transfer.list已经最新的支持version=4, system.transfer.list版本进化,这里针对不同的android版本,传入不同的version=1/2/3/4即可

    对common.py打patch
    diff --git a/tools/releasetools/common.py b/tools/releasetools/common.py
    index 22d95a9..4b981e3 100644
    --- a/tools/releasetools/common.py
    +++ b/tools/releasetools/common.py
    @@ -1406,6 +1406,12 @@ class BlockDifference(object):
         b = blockimgdiff.BlockImageDiff(tgt, src, threads=OPTIONS.worker_threads,
                                         version=self.version,
                                         disable_imgdiff=self.disable_imgdiff)
    +
    +    self.path = os.path.join(OPTIONS.outpath, partition)
    +    print (self.path)
    +     b.Compute(self.path )
    +    return
    +
         tmpdir = tempfile.mkdtemp()
         OPTIONS.tempfiles.append(tmpdir)
         self.path = os.path.join(tmpdir, partition)

    然后即可在android的根目录下面执行如下命令:
    ./build/tools/releasetools/img2sdat.py  system out/target/product/xxxx/system.img out/target/product/xxxx/sdat/
    Total of 475136 4096-byte output blocks in 2302 input chunks.
    Finding transfers...
    Generating digraph...
    Finding vertex sequence...
    Reversing backward edges...
      0/0 dependencies (0.00%) were violated; 0 source blocks stashed.
    Improving vertex order...
    Reticulating splines...
    940847104  940847104 (100.00%)     new __DATA 0-32765 32768-32769 32889-32890 65536-65537 66033-98301 98304-98305 98425-98426 98922-131070 131072-131073 131569-151714 163840-163841 163961-163962 164458-196605 196608-196609 229376-229377 229497-229498 229994-262141 262144-262145 294912-294913 295033-295034 295530-327677 327680-327681 360448-360449 393216-393217 425984-425985 458752-458753 459249-475135
    max stashed blocks: 0  (0 bytes), limit: <unknown>

    即可在目录 out/target/product/xxxx/sdat看到有system.new.dat与system.transfer.list文件生成。
    命令格式: img2sdat.py 分区名  img路径   new.dat路径

    eg:img2sdat.py  system  system.img  system_out_dir

    展开全文
  • 在用Windows系统的台式电脑给Android机顶盒刷机时,fastboot flash boot boot.img可以刷入;fastboot flash system system.img 却一直卡在sending system.img,解决办法:将刷机线从机箱前方的USB口移到后面

    在用Windows系统的台式电脑给Android机顶盒刷机时,fastboot flash boot boot.img可以刷入;

    fastboot flash system system.img 却一直卡在sending system.img,

    解决办法:

    将刷机线从机箱前方的USB口移到后面


    展开全文
  • Android system.img 解压-修改-打包

    千次阅读 2019-03-21 18:04:02
    在Android客制化案子中经常有种需求,在不重新编译源码的情况下修改Android的system.img例如对于不同客户需要更换不同的开机东环。那么本文就以这种需求为例讲解一下如何解压挂载Android系统的system.img然后修改...
  • system.img的打包和解压

    千次阅读 2019-05-20 11:31:02
    1、解压system.img 先用file命令查看system.img的文件类型 ronny@ronny:~/tmp$ file system.img system.img: data 我还没用simg2img转换 ronny@ronny:~/tools/simg2img system.img s.img 然后再用file命令 ronny@...
  • ubuntu 挂载 system.img

    2020-06-30 17:25:50
    1、安装simg2img: sudo apt-get install android-tools-... simg2img system.img system.img.ext4 3、挂载 sudo mkdir sysmain sudo mount -t ext4 -o loop system.img.ext4 sysmain cdsysmain ...
  • 如何从手机中提取system.img文件

    千次阅读 2020-10-30 17:57:45
    1, 首先给大家介绍一下 卡刷包转成线刷包 ... 提取码:qvdi 解压 Android 的第三方 ROM 包,把 system.new.dat 和 system.transfer.... 双击 sdat2img.bat 等待几秒即可生成新的 system.img 文件。 我这里使用...
  • 解压 Android 系统中的 system.img

    千次阅读 2019-01-15 15:11:20
    system.img 是什么 system.img 是 Android 系统中用来存放系统文件的镜像 (image) ,文件格式为 yaffs2 或者 ext 的文件系统 ,在 Android 源码编译后会生产该文件。它将被 init 进程通过解析 init.rc 文件挂载 ...
  • 系统System.img解包和重新打包过程

    千次阅读 2020-04-21 14:24:44
    系统System.img解包和重新打包过程 把system.img转换成ext4格式 ./simg2img system.img system_ext4.img 挂载ext4到systemMount目录进行修改 sudo mount system_ext4.img systemMount/ -o loop 修改完成后...
  • 解压system.img文件

    2014-09-26 11:40:37
    教你如何解压Android系统文件中的.img文件。
  • 挂载system.img

    2019-10-28 19:29:24
    将多个system压缩成单个img文件, 需要文件: generate_image(版本里有,img生成器) 所有的system.img文件以及system.ini文件 ./generate_image system.img 执行上面命令生成 system.img文件 file system.img ...
  • 在现实操作中我们经常会碰到把.dat转换成.img或者就是把.img转换成.dat的情况。 但如果直接使用安卓源代码工具在两者之间实现转换的话,会很麻烦, 而且并不是每一个人都懂得怎么使用代码去调用工具来实现转换。 ...
  • Android解压system.img

    2019-02-19 16:31:29
    android4.0之后,system.img文件格式为ext4,如果需要修改system.img文件,该如何做:  1.ubuntu系统,准备工具make_ext4fs、simg2img、mkusering.sh。  make_ext4fs、simg2img、mkusering.sh这三个工具可以在...
  • 怎么解压system.img文件

    千次阅读 2019-06-04 20:52:17
    system.img是官方的刷机包镜像,也就是安卓手机的系统,所有apk文件都在system.img里面,包括系统app文件,有时候精简误删了app,那么如果不重新刷机就没有办法恢复了吗?错!只有把系统文件重新放回去然后重启手机就能...
  • 1、环境配置 Debian或Ubuntu系统,配置Android开发工具 #apt-get update #apt-get install android-tools-adb android-tools-fastboot android-...2、system.img格式 Android sparse image #file system1.i...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 206,812
精华内容 82,724
关键字:

SYSTEM.img