【鸿蒙南向开发】稀疏镜像在OpenHarmony上的应用

最新推荐文章于 2024-09-11 13:08:56 发布
最新推荐文章于 2024-09-11 13:08:56 发布
阅读量718 收藏 26
点赞数 19
分类专栏： 前端 鸿蒙 安卓 文章标签： harmonyos android 华为 鸿蒙 前端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HarmonyOS_666/article/details/140754753
版权
前端 同时被 3 个专栏收录
199 篇文章 0 订阅
订阅专栏
鸿蒙
199 篇文章 11 订阅
订阅专栏
安卓
198 篇文章 0 订阅
订阅专栏

一、稀疏镜像升级背景

常用系统镜像格式为原始镜像，即RAW格式。镜像体积比较大，在烧录固件或者升级固件时比较耗时，而且在移动设备升级过程时比较耗费流量。为此，将原始镜像用稀疏描述，可以大大地缩减镜像体积，省时省流量。

二、稀疏镜像原理

1、稀疏镜像的概念

原始镜像：即raw image，完整的ext4分区镜像，包含很多全零的无效填充区
稀疏镜像：即sparse image，将raw ext4进行稀疏描述，因此尺寸比较小，制作目录有多少文件就计算多少，没有全零填充

2、稀疏镜像格式

在这里插入图片描述

稀疏镜像数据格式：首先是sparse_header占用28byte，然后是12byte的chunk_header，同样这chunk_header的类型决定了后面跟着的数据，如果读到数据是0xCAC1意味着后面是本身的raw_data，如果是0xCAC3，则后面num为0，接着再0xCAC2意味着后面填充4byte的内容。

三、实现稀疏镜像升级方案

版本基线：

OpenAtom OpenHarmony（以下简称“OpenHarmony”） 3.1 Release

代码路径：

https://gitee.com/openharmony/docs/blob/master/zh-cn/release-notes/OpenHarmony-v3.1-release.md

1、稀疏镜像烧录

（1）生成稀疏格式镜像
有2种方法可以生成稀疏镜像：
1）修改文件build/ohos_var.gni中，sparse_image=true

在这里插入图片描述

2）编译命令增加–sparse-image字段，
如./build.sh --product-name=xxx --sparse-image
（2）增加稀疏格式转换工具
在目录build/ohos/images/mkimage中增加文件img2simg，该工具用于编译完成后将raw镜像转换为sparse格式，并设置权限为777。
（3）编译后的镜像对比

在这里插入图片描述

编译出的镜像格式为sparse格式，镜像大小相比raw格式明显变小。
（4）烧录稀疏镜像
烧录稀疏镜像方法和烧录原始镜像方法一致。
稀疏镜像本身是不能直接挂载的，在烧录过程中通过uboot将稀疏格式镜像还原为原始镜像，然后写到磁盘中，系统启动后可挂载对应的镜像。

2、稀疏镜像升级

升级包采用稀疏镜像制作。
（1）修改升级包制作工具
官方升级包工具不支持生成稀疏镜像的升级包，修改升级包工具，生成稀疏格式的升级包。
.\base\update\packaging_tools\image_class.py

在这里插入图片描述

按照上图所示注释代码
（2）生成稀疏镜像升级包
和全量镜像升级包制作方法一致。
参考：

https://gitee.com/openharmony/docs/blob/master/zh-cn/device-dev/subsystems/subsys-ota-guide.md#%E6%A0%87%E5%87%86%E7%B3%BB%E7%BB%9F%E5%8D%87%E7%BA%A7%E5%8C%85%E5%88%B6%E4%BD%9C

（3）适配updater组件中稀疏镜像功能
● 增加写稀疏镜像分支
.\base\update\updater\services\applypatch\data_writer.cpp
写数据函数CreateDataWriter增加写稀疏镜像分支
case WRITE_SPARSE:

{
    std::unique_ptr<SparseWriter> writer(std::make_unique<SparseWriter>(partitionName));
    return std::move(writer);
}

● 增加稀疏镜像类声明
.\base\update\updater\services\applypatch\raw_writer.h
增加稀疏镜像类声明及相关变量定义

typedef struct sparse_header {
  uint32_t  magic;      /* 0xed26ff3a */
  uint16_t  major_version;  /* (0x1) - reject images with higher major versions */
  uint16_t  minor_version;  /* (0x0) - allow images with higer minor versions */
  uint16_t  file_hdr_sz;    /* 28 bytes for first revision of the file format */
  uint16_t  chunk_hdr_sz;   /* 12 bytes for first revision of the file format */
  uint32_t  blk_sz;     /* block size in bytes, must be a multiple of 4 (4096) */
  uint32_t  total_blks; /* total blocks in the non-sparse output image */
  uint32_t  total_chunks;   /* total chunks in the sparse input image */
  uint32_t  image_checksum; /* CRC32 checksum of the original data, counting "don't care" */
                /* as 0. Standard 802.3 polynomial, use a Public Domain */
                /* table implementation */
} sparse_header_t;
 
#define SPARSE_HEADER_MAGIC 0xed26ff3a
 
#define CHUNK_TYPE_RAW      0xCAC1
#define CHUNK_TYPE_FILL     0xCAC2
#define CHUNK_TYPE_DONT_CARE    0xCAC3
#define CHUNK_TYPE_CRC32    0xCAC4
 
typedef struct chunk_header {
  uint16_t  chunk_type; /* 0xCAC1 -> raw; 0xCAC2 -> fill; 0xCAC3 -> don't care */
  uint16_t  reserved1;
  uint32_t  chunk_sz;   /* in blocks in output image */
  uint32_t  total_sz;   /* in bytes of chunk input file including chunk header and data */
} chunk_header_t;
 
class SparseWriter : public DataWriter {
public:
    virtual bool Write(const uint8_t *addr, size_t len, WriteMode mode, const std::string &partitionName);
 
    explicit SparseWriter(const std::string partitionName) : offset_(0), fd_(-1), partitionName_(partitionName) {}
 
    virtual ~SparseWriter()
    {
        offset_ = 0;
        if (fd_ > 0) {
            fsync(fd_);
            close(fd_);
        }
        fd_ = -1;
    }
private:
    int WriteInternal(int fd, const uint8_t *data, size_t len, const std::string &partitionName);
 
    SparseWriter(const SparseWriter&) = delete;
 
    const SparseWriter& operator=(const SparseWriter&) = delete;
    off64_t offset_;
    int fd_;
    std::string partitionName_;
};

● 增加稀疏镜像类实现
.\base\update\updater\services\applypatch\raw_writer.cpp
增加稀疏镜像类实现及相关变量定义，原有代码不变

bool SparseWriter::Write(const uint8_t *addr, size_t len, WriteMode mode, const std::string &partitionName)
{
    if (addr == nullptr) {
        LOG(ERROR) << "SparseWriter: invalid address.";
        return false;
    }
    if (len == 0) {
        LOG(INFO) << "SparseWriter: write length is 0, skip.";
        return false;
    }
    if (fd_ < 0) {
        fd_ = OpenPartition(partitionName_);
        if (fd_ < 0) {
            return false;
        }
    }
 
    UPDATER_CHECK_ONLY_RETURN(WriteInternal(fd_, addr, len, partitionName_) >= 0, return false);
    return true;
}
 
 
int SparseWriter::WriteInternal(int fd, const uint8_t *data, size_t len, const std::string &partitionName)
{
    uint32_t written = 0;
    sparse_header_t *sparse_header;
    chunk_header_t *chunk_header;
    unsigned int chunk;
    void *membuf = NULL;
    uint32_t *fill_buf = NULL;
    uint32_t fill_val;
    uint32_t bytes_written = 0;
    uint32_t total_bytes = 0;
    uint32_t blk = 0;
    uint32_t chunk_data_sz = 0;
    uint32_t blkcnt = 0;
    uint32_t blks = 0;
    uint32_t total_blocks = 0;
    uint32_t addr_offset = 0;
    uint32_t fill_buf_num_blks = 0;
 
 
    uint32_t block_size = 4096;
    uint32_t block_count = 524288;
    uint32_t i;
    uint32_t j;
    int ret = lseek64(fd, offset_, SEEK_SET);
    UPDATER_FILE_CHECK(ret != -1, "RawWriter: failed to seek file to " << offset_, return -1);
    fill_buf_num_blks = CONFIG_FASTBOOT_FLASH_FILLBUF_SIZE / block_size; 
    LOG(INFO) << "WriteInternal offset_ " << offset_;
    /* Read and skip over sparse image header */
    sparse_header = (sparse_header_t *)data;
    data += sparse_header->file_hdr_sz;
    if (sparse_header->file_hdr_sz > sizeof(sparse_header_t)) {
        /*
         * Skip the remaining bytes in a header that is longer than
         * we expected.
         */
        data += (sparse_header->file_hdr_sz - sizeof(sparse_header_t));
    }
    LOG(INFO) << "=== Sparse Image Header ===";
    LOG(INFO) << "magic: "  << sparse_header->magic;
    LOG(INFO) << "major_version: " << sparse_header->major_version;
    LOG(INFO) << "minor_version: " << sparse_header->minor_version;
    LOG(INFO) << "file_hdr_sz: " << sparse_header->file_hdr_sz;
    LOG(INFO) << "chunk_hdr_sz: " << sparse_header->chunk_hdr_sz;
    LOG(INFO) << "blk_sz: " << sparse_header->blk_sz;
    LOG(INFO) << "total_blks: " << sparse_header->total_blks;
    LOG(INFO) << "total_chunks: " << sparse_header->total_chunks;
 
 
    LOG(INFO) << "Flashing Sparse Image";
    blk = 0;
    for (chunk = 0; chunk < sparse_header->total_chunks; chunk++) {
        /* Read and skip over chunk header */
        chunk_header = (chunk_header_t *)data;
        data += sizeof(chunk_header_t);
        if (chunk_header->chunk_type != CHUNK_TYPE_RAW) 
        {
            LOG(INFO) << "=== Chunk Header ===";
            LOG(INFO) << "chunk_type: " << chunk_header->chunk_type;
            LOG(INFO) << "chunk_sz: " << chunk_header->chunk_sz;
            LOG(INFO) << "total_sz: " << chunk_header->total_sz;
        }
        if (sparse_header->chunk_hdr_sz > sizeof(chunk_header_t)) {
            /*
             * Skip the remaining bytes in a header that is longer
             * than we expected.
             */
            data += (sparse_header->chunk_hdr_sz -
                 sizeof(chunk_header_t));
        }
        chunk_data_sz = sparse_header->blk_sz * chunk_header->chunk_sz;
        blkcnt = chunk_data_sz / block_size;
        switch (chunk_header->chunk_type) {
        case CHUNK_TYPE_RAW:
            if (chunk_header->total_sz !=
                (sparse_header->chunk_hdr_sz + chunk_data_sz)) {
                LOG(ERROR) << "Bogus chunk size for chunk type Raw";
                return -1;
            }
            if (blk + blkcnt > 0 + block_count) {
                LOG(ERROR) << "Request would exceed partition size!";
                return -1;
            }
            addr_offset = blk * block_size;
            ret = lseek64(fd, offset_ + addr_offset, SEEK_SET);
            if (ret < 0) {
                LOG(ERROR) << "failed to seek file to " << addr_offset << " error=" << strerror(errno);
                return -1;
            }
            written = write(fd, data, blkcnt * block_size);
            if (written < 0) {
                LOG(ERROR) << "SparseWriter: failed to write data of len ";
                return -1;
            }
            total_bytes = total_bytes + blkcnt * block_size;
            blks = written / block_size;
            blk += blks;
            bytes_written += blkcnt * block_size;
            total_blocks += chunk_header->chunk_sz;
            data += chunk_data_sz;
            break;
        case CHUNK_TYPE_FILL:
            if (chunk_header->total_sz !=
                (sparse_header->chunk_hdr_sz + sizeof(uint32_t))) {
                LOG(ERROR) << "Bogus chunk size for chunk type FILL total_sz err " << chunk_header->total_sz << "\n";
                return -1;
            }
            ret = posix_memalign (&membuf, 64, 
                        ROUNDUP(
                        block_size * fill_buf_num_blks,
                        64));
            if (ret) {
                LOG(ERROR) << "posix_memalign:" << strerror (errno);
                return -1;
            }
            fill_buf = (uint32_t *)membuf;
            if (!fill_buf) {
                LOG(ERROR) << "Malloc failed for: CHUNK_TYPE_FILL";
                return -1;
            }
            fill_val = *(uint32_t *)data;
            data = data + sizeof(uint32_t);
            for (i = 0;
                 i < (block_size * fill_buf_num_blks /
                  sizeof(fill_val));
                 i++)
                fill_buf[i] = fill_val;
            if (blk + blkcnt > 0 + block_count) {
                LOG(ERROR) << "Request would exceed partition size!";
                return -1;
            }
            for (i = 0; i < blkcnt;) {
                j = blkcnt - i;
                if (j > fill_buf_num_blks)
                    j = fill_buf_num_blks;
                addr_offset = blk * block_size;
                ret = lseek64(fd, offset_ + addr_offset, SEEK_SET);
                if (ret < 0) {
                    LOG(ERROR) << "failed to lseek file to " << addr_offset << " error=" << strerror(errno);
                    return -1;
                }
                written = write(fd, fill_buf, j * block_size);
                if (written < 0) {
                    LOG(ERROR) << "SparseWriter: failed to write data of len ";
                    return -1;
                }
                total_bytes = total_bytes + j * block_size;
                blks = written / block_size;
                if (blks < j) {
                    LOG(ERROR) << "Write failed, block";
                    free(fill_buf);
                    return -1;
                }
                blk += blks;
                i += j;
            }
            bytes_written += blkcnt * block_size;
            total_blocks += chunk_data_sz / sparse_header->blk_sz;
            free(fill_buf);
            break;
        case CHUNK_TYPE_DONT_CARE:
            blk += blkcnt;
            total_blocks += chunk_header->chunk_sz;
            break;
        case CHUNK_TYPE_CRC32:
            if (chunk_header->total_sz !=
                sparse_header->chunk_hdr_sz) {
                LOG(ERROR) << "Bogus chunk size for chunk type CRC32 total_sz err " << chunk_header->total_sz;
                return -1;
            }
            total_blocks += chunk_header->chunk_sz;
            data += chunk_data_sz;
            break;
        default:
            LOG(INFO) << __func__ << ": Unknown chunk type: " << chunk_header->chunk_type;
            return -1;
        }
    }
    LOG(INFO) << "Wrote "<< chunk <<"blocks, expected to write " << sparse_header->total_blks << "blocks\n";
    LOG(INFO) << "........ wrote "<< bytes_written <<"bytes to " << partitionName << "\n";
    LOG(INFO) << "total_bytes=" << total_bytes;
    return 0;
}

3、验证稀疏镜像升级

（1）拷贝升级包
将制作的稀疏镜像升级包通过HDC工具推进系统data目录，并修改文件名为updater.zip，路径如下：
/data/updater/updater.zip
（2）启动升级
系统启动后，在命令行工具输入如下命令启动升级
reboot updater:–update_package=/data/updater/updater.zip
输入命令后，系统重启，进入升级页面，等待升级完成。

本文介绍了OpenHarmony系统中实现稀疏镜像升级的方法，理解稀疏镜像原理及稀疏镜像还原方法可以快速在自己的系统中应用稀疏镜像升级，提高系统升级速度。

写在最后

有很多小伙伴不知道学习哪些鸿蒙开发技术？不知道需要重点掌握哪些鸿蒙应用开发知识点？而且学习时频繁踩坑，最终浪费大量时间。所以有一份实用的鸿蒙（HarmonyOS NEXT）文档用来跟着学习是非常有必要的。

这份鸿蒙（HarmonyOS NEXT）文档包含了鸿蒙开发必掌握的核心知识要点，内容包含了（ArkTS、ArkUI开发组件、Stage模型、多端部署、分布式应用开发、音频、视频、WebGL、OpenHarmony多媒体技术、Napi组件、OpenHarmony内核、OpenHarmony南向开发、鸿蒙项目实战等等）鸿蒙（HarmonyOS NEXT）技术知识点。

希望这一份鸿蒙学习文档能够给大家带来帮助，有需要的小伙伴自行领取，限时开源，先到先得~无套路领取！！

获取这份完整版高清学习路线，请点击→纯血版全套鸿蒙HarmonyOS学习文档

鸿蒙（HarmonyOS NEXT）5.0最新学习路线

在这里插入图片描述

有了路线图，怎么能没有学习文档呢，小编也准备了一份联合鸿蒙官方发布笔记整理收纳的一套系统性的鸿蒙（OpenHarmony ）学习手册（共计1236页）与鸿蒙（OpenHarmony ）开发入门教学视频，内容包含：ArkTS、ArkUI、Web开发、应用模型、资源分类…等知识点。

获取以上完整版高清学习路线，请点击→纯血版全套鸿蒙HarmonyOS学习文档

《鸿蒙 (OpenHarmony)开发入门教学视频》

在这里插入图片描述

《鸿蒙生态应用开发V3.0白皮书》

在这里插入图片描述

《鸿蒙 (OpenHarmony)开发基础到实战手册》

OpenHarmony北向、南向开发环境搭建

在这里插入图片描述

《鸿蒙开发基础》

●ArkTS语言
●安装DevEco Studio
●运用你的第一个ArkTS应用
●ArkUI声明式UI开发
.……
在这里插入图片描述

《鸿蒙开发进阶》

●Stage模型入门
●网络管理
●数据管理
●电话服务
●分布式应用开发
●通知与窗口管理
●多媒体技术
●安全技能
●任务管理
●WebGL
●国际化开发
●应用测试
●DFX面向未来设计
●鸿蒙系统移植和裁剪定制
……
在这里插入图片描述

《鸿蒙进阶实战》

●ArkTS实践
●UIAbility应用
●网络案例
……
在这里插入图片描述

获取以上完整鸿蒙HarmonyOS学习文档，请点击→纯血版全套鸿蒙HarmonyOS学习文档

「已注销」
关注
专栏目录
OpenHarmony 4.0 本地OTA升级
mart!nhu的博客
09-15 2871
OpenHarmony 3.2 本地OTA全量增量升级操作指南
关于socket里chunk问题的解决
Steven King
04-22 3426
前一段时间有人说自己碰到了http协议里的chunk问题，其实你自己实现chunk也可以，就是做个状态位的判断是了。本人实现过，在WTK虚拟机还没有公开的时候，但是wtk公开了你就用wtk里面的源马吧，写的很好，不过公开的代码里竟然少了行代码，这是在让我纳闷，不知道sun是故意的还是粗心，下面的代码增加了proxy支持，实在原有基础上改的，此代码已经应用很多应用，各位网友放心使用，有问题欢迎交流。
ChunkedInputStream 源码
stone2043的专栏
10-09 1041
Socket之Sun内置HttpClient解码类 ，解析HTTP协议 Transfer-Encoding:chunked package sun.net.www.http; import java.io.IOException; import sun.net.www.MessageHeader; import java.io.InputStream; public class Chun...
瑞芯微RK3568鸿蒙开发板OpenHarmony系统修改cfg文件权限方法
Industio_CSDN的博客
09-11 522
本文适用于OpenHarmony开源鸿蒙系统修改cfg文件权限方法，深圳触觉智能研发的RK3566、RK3568、RK3588等开发板、主板等产品均适用此教程
Nexus刷Android6.0
zhangmiaoping23的专栏
06-15 1523
1.下载Nexus 5官方Android 6.0.1刷机包: hammerhead-mmb29s-factory-6bfcdfa4.tgz (链接:https://dl.google.com/dl/android/aosp/hammerhead-mmb29s-factory-6bfcdfa4.tgz) 2.解压hammerhead-mmb29s-factory-6bfcdfa4.tgz到F:\NEXUS5_ANDROID6\hammerhead-mmb29s-factory-6bfcdfa4\hamm..
稀疏镜像在OpenHarmony上的应用
OpenHarmony_dev的博客
02-08 638
稀疏镜像数据格式：首先是sparse_header占用28byte，然后是12byte的chunk_header，同样这chunk_header的类型决定了后面跟着的数据，如果读到数据是0xCAC1意味着后面是本身的raw_data，如果是0xCAC3，则后面num为0，接着再0xCAC2意味着后面填充4byte的内容。本文介绍了OpenHarmony系统中实现稀疏镜像升级的方法，理解稀疏镜像原理及稀疏镜像还原方法可以快速在自己的系统中应用稀疏镜像升级，提高系统升级速度。增加稀疏镜像类声明及相关变量定义。
因子分解机在稀疏数据上超越支持向量机的应用介绍
最新发布
10-05
作者Steffen Rendle通过对稀疏数据的高效建模能力，展示了这种机器学习方法在高度稀疏问题（如推荐系统）领域的潜力及其线性计算复杂度带来的优化便利。 适合从事数据分析与机器学习的研发工作者和技术爱好者。 应用...
system系统镜像转换稀疏格式的相互转换
04-16
在IT行业中，系统镜像是一个重要的概念，尤其在Android设备的刷机和恢复过程中起着核心作用。系统镜像（System Image）包含了操作系统的核心部分、应用程序框架以及预装的应用程序，通常以完整的二进制形式存在。...
鸿蒙开发设备管理：【@ohos.update (升级)】
2301_76813281的博客
07-04 560
本模块首批接口从API version 6开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。点击或者复制转到。升级范围：升级整个系统，包括内置的资源、预置应用；第三方的应用不在升级的范围。升级依赖：升级分为SD卡升级和在线升级两种。
HarmonyOS鸿蒙最全最新OpenHarmony系统一二级目录整理_openharmony目录结构(4)，2024年最新阿里HarmonyOS鸿蒙研发岗二面
2401_84853389的博客
05-16 930
OpenHarmony主干代码获取方式一（推荐）：通过repo + ssh下载（需注册公钥，请参考码云帮助中心）。方式二：通过repo + https下载。现在代码已经获取到了，我们就可以展开来对一二级目录进行更深的认识。在此之气,我们来看一下tree的简单使用tree -L 2tree -d好的，学完这两个命令，我们就可以先运行tree -L 2 打印目录，总览一下。打印如下。
带你吃透RTMP
热门推荐
coding小世界
03-09 3万+
title: 带你吃透RTMP date: 2016-03-06 19:26:00tag: [RTMP, 协议]RTMP协议是Real Time Message Protocol(实时信息传输协议)的缩写，它是由Adobe公司提出的一种应用层的协议，用来解决多媒体数据传输流的多路复用（Multiplexing）和分包（packetizing）的问题。随着VR技术的发展，视频直播等领域逐渐活跃起来，
Pandas.ChunkSize()用法
nlovehao的博客
07-23 4953
据图：将Excel表格中的数据，每5行单独显示一次
结构化加权稀疏低秩恢复算法在人脸识别中的应用
"该资源是一篇关于结构化加权稀疏低秩恢复算法在人脸识别领域应用的学术论文，由吴小艺和吴小俊撰写，发表在《智能系统学报》第14卷第3期。该算法（Structured and Weighted Sparse Low Rank Representation, swLRR...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值