1# Base image class extension, inlined into every image.
2
3inherit image_version
4
5# Phosphor image types
6#
7# Phosphor OpenBMC supports a fixed partition mtd layout,
8# A dynamic mtd with ubi layout, and a tar file for use with
9# The reference BMC software update implementation.
10
11# Image composition
12FLASH_KERNEL_IMAGE ?= "fitImage-${INITRAMFS_IMAGE}-${MACHINE}-${MACHINE}"
13FLASH_KERNEL_IMAGE:df-obmc-ubi-fs ?= "fitImage-${MACHINE}.bin"
14
15IMAGE_BASETYPE ?= "squashfs-xz"
16OVERLAY_BASETYPE ?= "jffs2"
17FLASH_UBI_BASETYPE ?= "${IMAGE_BASETYPE}"
18FLASH_UBI_OVERLAY_BASETYPE ?= "ubifs"
19FLASH_EXT4_BASETYPE ?= "ext4"
20FLASH_EXT4_OVERLAY_BASETYPE ?= "ext4"
21
22IMAGE_TYPES += "mtd-static mtd-static-alltar mtd-static-tar mtd-ubi mtd-ubi-tar mmc-ext4-tar"
23
24IMAGE_TYPEDEP:mtd-static = "${IMAGE_BASETYPE}"
25IMAGE_TYPEDEP:mtd-static-tar = "${IMAGE_BASETYPE}"
26IMAGE_TYPEDEP:mtd-static-alltar = "mtd-static"
27IMAGE_TYPEDEP:mtd-ubi = "${FLASH_UBI_BASETYPE}"
28IMAGE_TYPEDEP:mtd-ubi-tar = "${FLASH_UBI_BASETYPE}"
29IMAGE_TYPEDEP:mmc-ext4-tar = "${FLASH_EXT4_BASETYPE}"
30IMAGE_TYPES_MASKED += "mtd-static mtd-static-alltar mtd-static-tar mtd-ubi mtd-ubi-tar mmc-ext4-tar"
31
32# Flash characteristics in KB unless otherwise noted
33DISTROOVERRIDES .= ":flash-${FLASH_SIZE}"
34FLASH_SIZE ?= "32768"
35FLASH_PEB_SIZE ?= "64"
36# Flash page and overhead sizes in bytes
37FLASH_PAGE_SIZE ?= "1"
38FLASH_NOR_UBI_OVERHEAD ?= "64"
39
40# Fixed partition offsets
41FLASH_UBOOT_SPL_SIZE ?= "64"
42FLASH_UBOOT_OFFSET ?= "0"
43FLASH_KERNEL_OFFSET ?= "512"
44FLASH_KERNEL_OFFSET:flash-65536 ?= "1024"
45FLASH_KERNEL_OFFSET:flash-131072 ?= "1024"
46FLASH_UBI_OFFSET ?= "${FLASH_KERNEL_OFFSET}"
47FLASH_ROFS_OFFSET ?= "4864"
48FLASH_ROFS_OFFSET:flash-65536 ?= "10240"
49FLASH_ROFS_OFFSET:flash-131072 ?= "10240"
50FLASH_RWFS_OFFSET ?= "28672"
51FLASH_RWFS_OFFSET:flash-65536 ?= "43008"
52FLASH_RWFS_OFFSET:flash-131072 ?= "98304"
53
54# UBI volume sizes in KB unless otherwise noted.
55FLASH_UBI_RWFS_SIZE ?= "6144"
56FLASH_UBI_RWFS_SIZE:flash-131072 ?= "32768"
57FLASH_UBI_RWFS_TXT_SIZE ?= "6MiB"
58FLASH_UBI_RWFS_TXT_SIZE:flash-131072 ?= "32MiB"
59
60# eMMC sizes in KB unless otherwise noted.
61MMC_UBOOT_SIZE ?= "1024"
62MMC_BOOT_PARTITION_SIZE ?= "65536"
63
64SIGNING_KEY ?= "${STAGING_DIR_NATIVE}${datadir}/OpenBMC.priv"
65INSECURE_KEY = "${@'${SIGNING_KEY}' == '${STAGING_DIR_NATIVE}${datadir}/OpenBMC.priv'}"
66SIGNING_KEY_DEPENDS = "${@oe.utils.conditional('INSECURE_KEY', 'True', 'phosphor-insecure-signing-key-native:do_populate_sysroot', '', d)}"
67
68VERSION_PURPOSE ?= "xyz.openbmc_project.Software.Version.VersionPurpose.BMC"
69
70UBOOT_SUFFIX ?= "bin"
71
72python() {
73    # Compute rwfs LEB count and LEB size.
74    page_size = d.getVar('FLASH_PAGE_SIZE', True)
75    nor_overhead_size = d.getVar('FLASH_NOR_UBI_OVERHEAD', True)
76    overhead_size = max(int(page_size), int(nor_overhead_size))
77    peb_size = d.getVar('FLASH_PEB_SIZE', True)
78    leb_size = (int(peb_size) * 1024) - (2 * overhead_size)
79    d.setVar('FLASH_LEB_SIZE', str(leb_size)) # In bytes
80
81    rwfs_size = d.getVar('FLASH_UBI_RWFS_SIZE', True)
82    rwfs_size = int(rwfs_size) * 1024
83    lebs = int((rwfs_size + leb_size - 1) / leb_size) # Rounding up
84    d.setVar('FLASH_UBI_RWFS_LEBS', str(lebs))
85}
86
87# Allow rwfs mkfs configuration through OVERLAY_MKFS_OPTS and OVERRIDES. However,
88# avoid setting 'ext4' or 'jffs2' in OVERRIDES as such raw filesystem types are
89# reserved for the primary image (and setting them currently breaks the build).
90# Instead, prefix the overlay override value with 'rwfs-' to avoid collisions.
91DISTROOVERRIDES .= ":static-rwfs-${OVERLAY_BASETYPE}"
92DISTROOVERRIDES .= ":ubi-rwfs-${FLASH_UBI_OVERLAY_BASETYPE}"
93DISTROOVERRIDES .= ":mmc-rwfs-${FLASH_EXT4_OVERLAY_BASETYPE}"
94
95JFFS2_RWFS_CMD = "mkfs.jffs2 --root=jffs2 --faketime --output=${IMGDEPLOYDIR}/${IMAGE_LINK_NAME}.jffs2"
96UBIFS_RWFS_CMD = "mkfs.ubifs -r ubifs -c ${FLASH_UBI_RWFS_LEBS} -m ${FLASH_PAGE_SIZE} -e ${FLASH_LEB_SIZE} ${IMGDEPLOYDIR}/${IMAGE_LINK_NAME}.ubifs"
97EXT4_RWFS_CMD = "mkfs.ext4 -F ${IMGDEPLOYDIR}/${IMAGE_LINK_NAME}.rwfs.ext4"
98
99FLASH_STATIC_RWFS_CMD:static-rwfs-jffs2 = "${JFFS2_RWFS_CMD}"
100FLASH_UBI_RWFS_CMD:ubi-rwfs-jffs2 = "${JFFS2_RWFS_CMD}"
101FLASH_UBI_RWFS_CMD:ubi-rwfs-ubifs = "${UBIFS_RWFS_CMD}"
102FLASH_EXT4_RWFS_CMD:mmc-rwfs-ext4 = "${EXT4_RWFS_CMD}"
103
104mk_empty_image() {
105	image_dst="$1"
106	image_size_kb=$2
107	dd if=/dev/zero bs=1k count=$image_size_kb \
108		| tr '\000' '\377' > $image_dst
109}
110
111mk_empty_image_zeros() {
112	image_dst="$1"
113	image_size_kb=$2
114	dd if=/dev/zero of=$image_dst bs=1k count=$image_size_kb
115}
116
117clean_rwfs() {
118	type=$1
119	shift
120
121	rm -f ${IMGDEPLOYDIR}/${IMAGE_LINK_NAME}.$type
122	rm -rf $type
123	mkdir $type
124}
125
126make_rwfs() {
127	type=$1
128	cmd=$2
129	shift
130	shift
131	opts="$@"
132
133	mkdir -p $type
134
135	$cmd $opts
136}
137
138do_generate_rwfs_static() {
139	clean_rwfs ${OVERLAY_BASETYPE}
140	make_rwfs ${OVERLAY_BASETYPE} "${FLASH_STATIC_RWFS_CMD}" ${OVERLAY_MKFS_OPTS}
141}
142do_generate_rwfs_static[dirs] = " ${S}/static"
143do_generate_rwfs_static[depends] += " \
144        mtd-utils-native:do_populate_sysroot \
145        "
146
147do_generate_rwfs_ubi() {
148	clean_rwfs ${FLASH_UBI_OVERLAY_BASETYPE}
149	make_rwfs ${FLASH_UBI_OVERLAY_BASETYPE} "${FLASH_UBI_RWFS_CMD}"
150}
151do_generate_rwfs_ubi[dirs] = " ${S}/ubi"
152do_generate_rwfs_ubi[depends] += " \
153        mtd-utils-native:do_populate_sysroot \
154        "
155
156do_generate_rwfs_ext4() {
157	clean_rwfs rwfs.${FLASH_EXT4_OVERLAY_BASETYPE}
158	mk_empty_image ${IMGDEPLOYDIR}/${IMAGE_LINK_NAME}.rwfs.ext4 1024
159	make_rwfs ${FLASH_EXT4_OVERLAY_BASETYPE} "${FLASH_EXT4_RWFS_CMD}" ${OVERLAY_MKFS_OPTS}
160}
161do_generate_rwfs_ext4[dirs] = " ${S}/ext4"
162do_generate_rwfs_ext4[depends] += " \
163        e2fsprogs-native:do_populate_sysroot \
164        "
165
166add_volume() {
167	config_file=$1
168	vol_id=$2
169	vol_type=$3
170	vol_name=$4
171	image=$5
172	vol_size=$6
173
174	echo \[$vol_name\] >> $config_file
175	echo mode=ubi >> $config_file
176	echo image=$image >> $config_file
177	echo vol_type=$vol_type >> $config_file
178	echo vol_name=$vol_name >> $config_file
179	echo vol_id=$vol_id >> $config_file
180	if [ ! -z $vol_size ]; then
181		echo vol_size=$vol_size >> $config_file
182	fi
183}
184
185python do_generate_ubi() {
186        version_id = do_get_versionID(d)
187        d.setVar('VERSION_ID', version_id)
188        bb.build.exec_func("do_make_ubi", d)
189}
190do_generate_ubi[dirs] = "${S}/ubi"
191do_generate_ubi[depends] += " \
192        ${PN}:do_image_${@d.getVar('FLASH_UBI_BASETYPE', True).replace('-', '_')} \
193        virtual/kernel:do_deploy \
194        u-boot:do_deploy \
195        mtd-utils-native:do_populate_sysroot \
196        "
197
198do_make_ubi() {
199	cfg=ubinize-${IMAGE_NAME}.cfg
200	rm -f $cfg ubi-img
201	# Construct the ubinize config file
202	add_volume $cfg 0 static kernel-${VERSION_ID} \
203		${DEPLOY_DIR_IMAGE}/${FLASH_KERNEL_IMAGE}
204
205	add_volume $cfg 1 static rofs-${VERSION_ID} \
206		${IMGDEPLOYDIR}/${IMAGE_LINK_NAME}.${FLASH_UBI_BASETYPE}
207
208	add_volume $cfg 2 dynamic rwfs ${IMGDEPLOYDIR}/${IMAGE_LINK_NAME}.${FLASH_UBI_OVERLAY_BASETYPE} ${FLASH_UBI_RWFS_TXT_SIZE}
209
210	# Build the ubi partition image
211	ubinize -p ${FLASH_PEB_SIZE}KiB -m ${FLASH_PAGE_SIZE} -o ubi-img $cfg
212
213	# Concatenate the uboot and ubi partitions
214	mk_empty_image ${IMGDEPLOYDIR}/${IMAGE_NAME}.ubi.mtd ${FLASH_SIZE}
215	dd bs=1k conv=notrunc seek=${FLASH_UBOOT_OFFSET} \
216		if=${DEPLOY_DIR_IMAGE}/u-boot.${UBOOT_SUFFIX} \
217		of=${IMGDEPLOYDIR}/${IMAGE_NAME}.ubi.mtd
218	dd bs=1k conv=notrunc seek=${FLASH_UBI_OFFSET} \
219		if=ubi-img \
220		of=${IMGDEPLOYDIR}/${IMAGE_NAME}.ubi.mtd
221
222	cd ${IMGDEPLOYDIR}
223	ln -sf ${IMAGE_NAME}.ubi.mtd ${IMGDEPLOYDIR}/${IMAGE_LINK_NAME}.ubi.mtd
224}
225do_make_ubi[dirs] = "${S}/ubi"
226do_make_ubi[depends] += " \
227        ${PN}:do_image_${@d.getVar('FLASH_UBI_BASETYPE', True).replace('-', '_')} \
228        virtual/kernel:do_deploy \
229        u-boot:do_deploy \
230        mtd-utils-native:do_populate_sysroot \
231        "
232
233do_mk_static_nor_image() {
234	# Assemble the flash image
235	mk_empty_image ${IMGDEPLOYDIR}/${IMAGE_NAME}.static.mtd ${FLASH_SIZE}
236}
237
238do_generate_image_uboot_file() {
239    image_dst="$1"
240    uboot_offset=${FLASH_UBOOT_OFFSET}
241
242    if [ ! -z ${SPL_BINARY} ]; then
243        dd bs=1k conv=notrunc seek=${FLASH_UBOOT_OFFSET} \
244            if=${DEPLOY_DIR_IMAGE}/u-boot-spl.${UBOOT_SUFFIX} \
245            of=${image_dst}
246        uboot_offset=${FLASH_UBOOT_SPL_SIZE}
247    fi
248
249    dd bs=1k conv=notrunc seek=${uboot_offset} \
250        if=${DEPLOY_DIR_IMAGE}/u-boot.${UBOOT_SUFFIX} \
251        of=${image_dst}
252}
253
254python do_generate_static() {
255    import subprocess
256
257    bb.build.exec_func("do_mk_static_nor_image", d)
258
259    nor_image = os.path.join(d.getVar('IMGDEPLOYDIR', True),
260                             '%s.static.mtd' % d.getVar('IMAGE_NAME', True))
261
262    def _append_image(imgpath, start_kb, finish_kb):
263        imgsize = os.path.getsize(imgpath)
264        maxsize = (finish_kb - start_kb) * 1024
265        bb.debug(1, 'Considering file size=' + str(imgsize) + ' name=' + imgpath)
266        bb.debug(1, 'Spanning start=' + str(start_kb) + 'K end=' + str(finish_kb) + 'K')
267        bb.debug(1, 'Compare needed=' + str(imgsize) + ' available=' + str(maxsize) + ' margin=' + str(maxsize - imgsize))
268        if imgsize > maxsize:
269            bb.fatal("Image '%s' is too large!" % imgpath)
270
271        subprocess.check_call(['dd', 'bs=1k', 'conv=notrunc',
272                               'seek=%d' % start_kb,
273                               'if=%s' % imgpath,
274                               'of=%s' % nor_image])
275
276    uboot_offset = int(d.getVar('FLASH_UBOOT_OFFSET', True))
277
278    spl_binary = d.getVar('SPL_BINARY', True)
279    if spl_binary:
280        _append_image(os.path.join(d.getVar('DEPLOY_DIR_IMAGE', True),
281                                   'u-boot-spl.%s' % d.getVar('UBOOT_SUFFIX',True)),
282                      int(d.getVar('FLASH_UBOOT_OFFSET', True)),
283                      int(d.getVar('FLASH_UBOOT_SPL_SIZE', True)))
284        uboot_offset += int(d.getVar('FLASH_UBOOT_SPL_SIZE', True))
285
286    _append_image(os.path.join(d.getVar('DEPLOY_DIR_IMAGE', True),
287                               'u-boot.%s' % d.getVar('UBOOT_SUFFIX',True)),
288                  uboot_offset,
289                  int(d.getVar('FLASH_KERNEL_OFFSET', True)))
290
291    _append_image(os.path.join(d.getVar('DEPLOY_DIR_IMAGE', True),
292                               d.getVar('FLASH_KERNEL_IMAGE', True)),
293                  int(d.getVar('FLASH_KERNEL_OFFSET', True)),
294                  int(d.getVar('FLASH_ROFS_OFFSET', True)))
295
296    _append_image(os.path.join(d.getVar('IMGDEPLOYDIR', True),
297                               '%s.%s' % (
298                                    d.getVar('IMAGE_LINK_NAME', True),
299                                    d.getVar('IMAGE_BASETYPE', True))),
300                  int(d.getVar('FLASH_ROFS_OFFSET', True)),
301                  int(d.getVar('FLASH_RWFS_OFFSET', True)))
302
303    _append_image(os.path.join(d.getVar('IMGDEPLOYDIR', True),
304                               '%s.%s' % (
305                                    d.getVar('IMAGE_LINK_NAME', True),
306                                    d.getVar('OVERLAY_BASETYPE', True))),
307                  int(d.getVar('FLASH_RWFS_OFFSET', True)),
308                  int(d.getVar('FLASH_SIZE', True)))
309
310    bb.build.exec_func("do_mk_static_symlinks", d)
311}
312
313do_mk_static_symlinks() {
314	cd ${IMGDEPLOYDIR}
315	ln -sf ${IMAGE_NAME}.static.mtd ${IMGDEPLOYDIR}/${IMAGE_LINK_NAME}.static.mtd
316
317	# Maintain non-standard legacy links
318	do_generate_image_uboot_file ${IMGDEPLOYDIR}/image-u-boot
319	ln -sf ${IMAGE_NAME}.static.mtd ${IMGDEPLOYDIR}/flash-${MACHINE}
320	ln -sf ${IMAGE_NAME}.static.mtd ${IMGDEPLOYDIR}/image-bmc
321	ln -sf ${FLASH_KERNEL_IMAGE} ${IMGDEPLOYDIR}/image-kernel
322	ln -sf ${IMAGE_LINK_NAME}.${IMAGE_BASETYPE} ${IMGDEPLOYDIR}/image-rofs
323	ln -sf ${IMAGE_LINK_NAME}.${OVERLAY_BASETYPE} ${IMGDEPLOYDIR}/image-rwfs
324}
325do_generate_static[dirs] = "${S}/static"
326do_generate_static[depends] += " \
327        ${PN}:do_image_${@d.getVar('IMAGE_BASETYPE', True).replace('-', '_')} \
328        virtual/kernel:do_deploy \
329        u-boot:do_deploy \
330        "
331
332make_signatures() {
333	signature_files=""
334	for file in "$@"; do
335		openssl dgst -sha256 -sign ${SIGNING_KEY} -out "${file}.sig" $file
336		signature_files="${signature_files} ${file}.sig"
337	done
338
339	if [ -n "$signature_files" ]; then
340		sort_signature_files=`echo "$signature_files" | tr ' ' '\n' | sort | tr '\n' ' '`
341		cat $sort_signature_files > image-full
342		openssl dgst -sha256 -sign ${SIGNING_KEY} -out image-full.sig image-full
343		signature_files="${signature_files} image-full.sig"
344	fi
345}
346
347do_generate_static_alltar() {
348	ln -sf ${S}/MANIFEST MANIFEST
349	ln -sf ${S}/publickey publickey
350	ln -sf ${IMGDEPLOYDIR}/${IMAGE_LINK_NAME}.static.mtd image-bmc
351
352	make_signatures image-bmc MANIFEST publickey
353
354	tar -h -cvf ${IMGDEPLOYDIR}/${IMAGE_NAME}.static.mtd.all.tar \
355	    image-bmc MANIFEST publickey ${signature_files}
356
357	cd ${IMGDEPLOYDIR}
358
359	ln -sf ${IMAGE_NAME}.static.mtd.all.tar \
360		${IMGDEPLOYDIR}/${IMAGE_LINK_NAME}.static.mtd.all.tar
361
362	# Maintain non-standard legacy link.
363	ln -sf ${IMAGE_NAME}.static.mtd.all.tar \
364		${IMGDEPLOYDIR}/${MACHINE}-${DATETIME}.all.tar
365
366}
367do_generate_static_alltar[vardepsexclude] = "DATETIME"
368do_generate_static_alltar[dirs] = "${S}/static"
369do_generate_static_alltar[depends] += " \
370        openssl-native:do_populate_sysroot \
371        ${SIGNING_KEY_DEPENDS} \
372        ${PN}:do_copy_signing_pubkey \
373        "
374
375make_image_links() {
376	rwfs=$1
377	rofs=$2
378	shift
379	shift
380
381	# Create some links to help make the tar archive in the format
382	# expected by phosphor-bmc-code-mgmt.
383	do_generate_image_uboot_file image-u-boot
384	ln -sf ${DEPLOY_DIR_IMAGE}/${FLASH_KERNEL_IMAGE} image-kernel
385	ln -sf ${IMGDEPLOYDIR}/${IMAGE_LINK_NAME}.$rofs image-rofs
386	ln -sf ${IMGDEPLOYDIR}/${IMAGE_LINK_NAME}.$rwfs image-rwfs
387}
388
389make_tar_of_images() {
390	type=$1
391	shift
392	extra_files="$@"
393
394	# Create the tar archive
395	tar -h -cvf ${IMGDEPLOYDIR}/${IMAGE_NAME}.$type.tar \
396		image-u-boot image-kernel image-rofs image-rwfs $extra_files
397
398	cd ${IMGDEPLOYDIR}
399	ln -sf ${IMAGE_NAME}.$type.tar ${IMGDEPLOYDIR}/${IMAGE_LINK_NAME}.$type.tar
400}
401
402do_generate_static_tar() {
403	ln -sf ${S}/MANIFEST MANIFEST
404	ln -sf ${S}/publickey publickey
405	make_image_links ${OVERLAY_BASETYPE} ${IMAGE_BASETYPE}
406	make_signatures image-u-boot image-kernel image-rofs image-rwfs MANIFEST publickey
407	make_tar_of_images static.mtd MANIFEST publickey ${signature_files}
408
409	# Maintain non-standard legacy link.
410	cd ${IMGDEPLOYDIR}
411	ln -sf ${IMAGE_NAME}.static.mtd.tar ${IMGDEPLOYDIR}/${MACHINE}-${DATETIME}.tar
412}
413do_generate_static_tar[dirs] = " ${S}/static"
414do_generate_static_tar[depends] += " \
415        ${PN}:do_image_${@d.getVar('IMAGE_BASETYPE', True).replace('-', '_')} \
416        virtual/kernel:do_deploy \
417        u-boot:do_deploy \
418        openssl-native:do_populate_sysroot \
419        ${SIGNING_KEY_DEPENDS} \
420        ${PN}:do_copy_signing_pubkey \
421        "
422do_generate_static_tar[vardepsexclude] = "DATETIME"
423
424do_generate_ubi_tar() {
425	ln -sf ${S}/MANIFEST MANIFEST
426	ln -sf ${S}/publickey publickey
427	make_image_links ${FLASH_UBI_OVERLAY_BASETYPE} ${FLASH_UBI_BASETYPE}
428	make_signatures image-u-boot image-kernel image-rofs image-rwfs MANIFEST publickey
429	make_tar_of_images ubi.mtd MANIFEST publickey ${signature_files}
430}
431do_generate_ubi_tar[dirs] = " ${S}/ubi"
432do_generate_ubi_tar[depends] += " \
433        ${PN}:do_image_${@d.getVar('FLASH_UBI_BASETYPE', True).replace('-', '_')} \
434        virtual/kernel:do_deploy \
435        u-boot:do_deploy \
436        openssl-native:do_populate_sysroot \
437        ${SIGNING_KEY_DEPENDS} \
438        ${PN}:do_copy_signing_pubkey \
439        "
440
441do_generate_ext4_tar() {
442	# Generate the U-Boot image
443	mk_empty_image_zeros image-u-boot ${MMC_UBOOT_SIZE}
444	do_generate_image_uboot_file image-u-boot
445
446	# Generate a compressed ext4 filesystem with the fitImage file in it to be
447	# flashed to the boot partition of the eMMC
448	install -d boot-image
449	install -m 644 ${DEPLOY_DIR_IMAGE}/${FLASH_KERNEL_IMAGE} boot-image/fitImage
450	mk_empty_image_zeros boot-image.${FLASH_EXT4_BASETYPE} ${MMC_BOOT_PARTITION_SIZE}
451	mkfs.ext4 -F -i 4096 -d boot-image boot-image.${FLASH_EXT4_BASETYPE}
452	# Error codes 0-3 indicate successfull operation of fsck
453	fsck.ext4 -pvfD boot-image.${FLASH_EXT4_BASETYPE} || [ $? -le 3 ]
454	zstd -f -k -T0 -c ${ZSTD_COMPRESSION_LEVEL} boot-image.${FLASH_EXT4_BASETYPE} > boot-image.${FLASH_EXT4_BASETYPE}.zst
455
456	# Generate the compressed ext4 rootfs
457	zstd -f -k -T0 -c ${ZSTD_COMPRESSION_LEVEL} ${IMGDEPLOYDIR}/${IMAGE_LINK_NAME}.${FLASH_EXT4_BASETYPE} > ${IMAGE_LINK_NAME}.${FLASH_EXT4_BASETYPE}.zst
458
459	ln -sf boot-image.${FLASH_EXT4_BASETYPE}.zst image-kernel
460	ln -sf ${IMAGE_LINK_NAME}.${FLASH_EXT4_BASETYPE}.zst image-rofs
461	ln -sf ${IMGDEPLOYDIR}/${IMAGE_LINK_NAME}.rwfs.${FLASH_EXT4_OVERLAY_BASETYPE} image-rwfs
462	ln -sf ${S}/MANIFEST MANIFEST
463	ln -sf ${S}/publickey publickey
464
465	hostfw_update_file="${DEPLOY_DIR_IMAGE}/hostfw/update/image-hostfw"
466	if [ -e "${hostfw_update_file}" ]; then
467		ln -sf "${hostfw_update_file}" image-hostfw
468		make_signatures image-u-boot image-kernel image-rofs image-rwfs MANIFEST publickey image-hostfw
469		make_tar_of_images ext4.mmc MANIFEST publickey ${signature_files} image-hostfw
470	else
471		make_signatures image-u-boot image-kernel image-rofs image-rwfs MANIFEST publickey
472		make_tar_of_images ext4.mmc MANIFEST publickey ${signature_files}
473	fi
474}
475do_generate_ext4_tar[dirs] = " ${S}/ext4"
476do_generate_ext4_tar[depends] += " \
477        zstd-native:do_populate_sysroot \
478        ${PN}:do_image_${FLASH_EXT4_BASETYPE} \
479        virtual/kernel:do_deploy \
480        u-boot:do_deploy \
481        openssl-native:do_populate_sysroot \
482        ${SIGNING_KEY_DEPENDS} \
483        ${PN}:do_copy_signing_pubkey \
484        phosphor-hostfw-image:do_deploy \
485        "
486
487def get_pubkey_basedir(d):
488    return os.path.join(
489        d.getVar('STAGING_DIR_TARGET', True),
490        d.getVar('sysconfdir', True).strip(os.sep),
491        'activationdata')
492
493def get_pubkey_type(d):
494    return os.listdir(get_pubkey_basedir(d))[0]
495
496def get_pubkey_path(d):
497    return os.path.join(
498        get_pubkey_basedir(d),
499        get_pubkey_type(d),
500        'publickey')
501
502python do_generate_phosphor_manifest() {
503    purpose = d.getVar('VERSION_PURPOSE', True)
504    version = do_get_version(d)
505    build_id = do_get_buildID(d)
506    target_machine = d.getVar('MACHINE', True)
507    extended_version = (d.getVar('EXTENDED_VERSION', True) or "")
508    with open('MANIFEST', 'w') as fd:
509        fd.write('purpose={}\n'.format(purpose))
510        fd.write('version={}\n'.format(version.strip('"')))
511        fd.write('BuildId={}\n'.format(build_id.strip('"')))
512        fd.write('ExtendedVersion={}\n'.format(extended_version))
513        fd.write('KeyType={}\n'.format(get_pubkey_type(d)))
514        fd.write('HashType=RSA-SHA256\n')
515        fd.write('MachineName={}\n'.format(target_machine))
516}
517do_generate_phosphor_manifest[dirs] = "${S}"
518do_generate_phosphor_manifest[depends] += " \
519        os-release:do_populate_sysroot \
520        phosphor-image-signing:do_populate_sysroot \
521        "
522
523python do_copy_signing_pubkey() {
524    with open(get_pubkey_path(d), 'r') as read_fd:
525        with open('publickey', 'w') as write_fd:
526            write_fd.write(read_fd.read())
527}
528
529do_copy_signing_pubkey[dirs] = "${S}"
530do_copy_signing_pubkey[depends] += " \
531        phosphor-image-signing:do_populate_sysroot \
532        "
533
534addtask copy_signing_pubkey after do_rootfs
535addtask generate_phosphor_manifest after do_rootfs
536addtask generate_rwfs_static after do_rootfs
537addtask generate_rwfs_ubi after do_rootfs
538addtask generate_rwfs_ext4 after do_rootfs
539
540python() {
541    types = d.getVar('IMAGE_FSTYPES', True).split()
542
543    if any([x in types for x in ['mtd-static', 'mtd-static-alltar']]):
544        bb.build.addtask(
545                'do_generate_static',
546                'do_image_complete',
547                'do_generate_rwfs_static', d)
548    if 'mtd-static-alltar' in types:
549        bb.build.addtask(
550                'do_generate_static_alltar',
551                'do_image_complete',
552                'do_generate_static do_generate_phosphor_manifest', d)
553    if 'mtd-static-tar' in types:
554        bb.build.addtask(
555                'do_generate_static_tar',
556                'do_image_complete',
557                'do_generate_rwfs_static do_generate_phosphor_manifest', d)
558
559    if 'mtd-ubi' in types:
560        bb.build.addtask(
561                'do_generate_ubi',
562                'do_image_complete',
563                'do_generate_rwfs_ubi', d)
564    if 'mtd-ubi-tar' in types:
565        bb.build.addtask(
566                'do_generate_ubi_tar',
567                'do_image_complete',
568                'do_generate_rwfs_ubi do_generate_phosphor_manifest', d)
569
570    if 'mmc-ext4-tar' in types:
571        bb.build.addtask(
572                'do_generate_ext4_tar',
573                'do_image_complete',
574                'do_generate_rwfs_ext4 do_generate_phosphor_manifest', d)
575}
576