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 target_machine = d.getVar('MACHINE', True) 506 extended_version = (d.getVar('EXTENDED_VERSION', True) or "") 507 with open('MANIFEST', 'w') as fd: 508 fd.write('purpose={}\n'.format(purpose)) 509 fd.write('version={}\n'.format(version.strip('"'))) 510 fd.write('ExtendedVersion={}\n'.format(extended_version)) 511 fd.write('KeyType={}\n'.format(get_pubkey_type(d))) 512 fd.write('HashType=RSA-SHA256\n') 513 fd.write('MachineName={}\n'.format(target_machine)) 514} 515do_generate_phosphor_manifest[dirs] = "${S}" 516do_generate_phosphor_manifest[depends] += " \ 517 os-release:do_populate_sysroot \ 518 phosphor-image-signing:do_populate_sysroot \ 519 " 520 521python do_copy_signing_pubkey() { 522 with open(get_pubkey_path(d), 'r') as read_fd: 523 with open('publickey', 'w') as write_fd: 524 write_fd.write(read_fd.read()) 525} 526 527do_copy_signing_pubkey[dirs] = "${S}" 528do_copy_signing_pubkey[depends] += " \ 529 phosphor-image-signing:do_populate_sysroot \ 530 " 531 532addtask copy_signing_pubkey after do_rootfs 533addtask generate_phosphor_manifest after do_rootfs 534addtask generate_rwfs_static after do_rootfs 535addtask generate_rwfs_ubi after do_rootfs 536addtask generate_rwfs_ext4 after do_rootfs 537 538python() { 539 types = d.getVar('IMAGE_FSTYPES', True).split() 540 541 if any([x in types for x in ['mtd-static', 'mtd-static-alltar']]): 542 bb.build.addtask( 543 'do_generate_static', 544 'do_image_complete', 545 'do_generate_rwfs_static', d) 546 if 'mtd-static-alltar' in types: 547 bb.build.addtask( 548 'do_generate_static_alltar', 549 'do_image_complete', 550 'do_generate_static do_generate_phosphor_manifest', d) 551 if 'mtd-static-tar' in types: 552 bb.build.addtask( 553 'do_generate_static_tar', 554 'do_image_complete', 555 'do_generate_rwfs_static do_generate_phosphor_manifest', d) 556 557 if 'mtd-ubi' in types: 558 bb.build.addtask( 559 'do_generate_ubi', 560 'do_image_complete', 561 'do_generate_rwfs_ubi', d) 562 if 'mtd-ubi-tar' in types: 563 bb.build.addtask( 564 'do_generate_ubi_tar', 565 'do_image_complete', 566 'do_generate_rwfs_ubi do_generate_phosphor_manifest', d) 567 568 if 'mmc-ext4-tar' in types: 569 bb.build.addtask( 570 'do_generate_ext4_tar', 571 'do_image_complete', 572 'do_generate_rwfs_ext4 do_generate_phosphor_manifest', d) 573} 574