1#!/bin/bash 2set -eo pipefail 3 4# Get the root mtd device number (mtdX) from "/dev/ubiblockX_Y on /" 5findrootmtd() { 6 rootmatch=" on / " 7 m="$(mount | grep "${rootmatch}" | grep "ubiblock")" 8 m="${m##*ubiblock}" 9 m="${m%_*}" 10 if [ -z "${m}" ]; then 11 # default to bmc mtd (0) 12 m=0 13 fi 14 echo "mtd${m}" 15} 16 17findrootubi() { 18 rootmatch=" on / " 19 m="$(mount | grep "${rootmatch}")" 20 m="${m##*ubiblock}" 21 m="${m% on*}" 22 echo "ubi${m}" 23} 24 25# Get the mtd device number (mtdX) 26findmtd() { 27 m="$(grep -xl "$1" /sys/class/mtd/*/name)" 28 m="${m%/name}" 29 m="${m##*/}" 30 echo "${m}" 31} 32 33# Get the mtd device number only (return X of mtdX) 34findmtdnum() { 35 m="$(findmtd "$1")" 36 m="${m##mtd}" 37 echo "${m}" 38} 39 40# Get the ubi device number (ubiX_Y) 41findubi() { 42 u="$(grep -xl "$1" /sys/class/ubi/ubi?/subsystem/ubi*/name)" 43 u="${u%/name}" 44 u="${u##*/}" 45 echo "${u}" 46} 47 48# Get the ubi device number (ubiX_Y) on a specific mtd 49findubi_onmtd() { 50 u="$(grep -xl "$1" /sys/class/ubi/ubi"$2"/subsystem/ubi"$2"*/name)" 51 u="${u%/name}" 52 u="${u##*/}" 53 echo "${u}" 54} 55 56# Get all ubi device names on a specific mtd that match requested string 57findubiname_onmtd() { 58 u="$(grep -h "$1" /sys/class/ubi/ubi"$2"/subsystem/ubi"$2"*/name)" 59 u="${u%/name}" 60 u="${u##*/}" 61 echo "${u}" 62} 63 64# Get the name from the requested ubiX_Y volume 65findname() { 66 n="$(cat /sys/class/ubi/$1/name)" 67 echo "${n}" 68} 69 70# Set the version path property to the flash location where the image was 71# successfully flashed 72set_flashid() { 73 busctl set-property xyz.openbmc_project.Software.BMC.Updater \ 74 "/xyz/openbmc_project/software/${version}" \ 75 xyz.openbmc_project.Common.FilePath \ 76 Path s "$1" 77} 78 79# Set the u-boot envs that perform a side switch on failure to boot 80set_wdt2bite() { 81 if ! fw_printenv wdt2bite 2>/dev/null; then 82 fw_setenv wdt2bite "mw.l 0x1e785024 0xa 1; mw.b 0x1e78502c 0xb3 1" 83 fw_setenv bootalt "run wdt2bite" 84 fw_setenv obmc_bootcmd "ubi part obmc-ubi; run do_rwreset; ubi read \ 85\${loadaddr} \${kernelname}; bootm \${loadaddr} || run bootalt" 86 fi 87} 88 89# Make space on flash before creating new volumes. This can be enhanced 90# determine current flash usage. For now only keep a "keepmax" number of them 91ubi_remove_volumes() 92{ 93 rootubi="$(findrootubi)" 94 rootname="$(findname "${rootubi}")" 95 rootversion="${rootname##*-}" 96 rootkernel="kernel-${rootversion}" 97 98 # Just keep max number of volumes before updating, don't delete the version 99 # the BMC is booted from, and when a version is identified to be deleted, 100 # delete both the rofs and kernel volumes for that version. 101 rmnames="$(findubiname_onmtd "${name%-*}-" "${ro}")" 102 rmnames=(${rmnames}) 103 ubicount="${#rmnames[@]}" 104 while [ ${ubicount} -ge ${keepmax} ]; do 105 # Loop through existing volumes and skip currently active ones 106 for (( index=0; index<${#rmnames[@]}; index++ )); do 107 rmname="${rmnames[${index}]}" 108 rmversion="${rmname##*-}" 109 [ "${rmversion}" == "${version}" ] && continue 110 rmubi="$(findubi_onmtd "rofs-${rmversion}" "${ro}")" 111 if [[ ( "${rmubi}" != "${rootubi}" ) && 112 ( "${rmname}" != "${rootkernel}" ) ]]; then 113 ubi_remove "rofs-${rmversion}" "${ro}" 114 ubi_remove "kernel-${rmversion}" "${ro}" 115 # Remove priority value 116 fw_setenv "${rmversion}" 117 break 118 fi 119 done 120 # Decrease count regardless to avoid an infinite loop 121 (( ubicount-- )) 122 done 123} 124 125ubi_rw() { 126 rwmtd="$(findmtd "${reqmtd}")" 127 rw="${rwmtd#mtd}" 128 ubidev="/dev/ubi${rw}" 129 130 # Update rwfs_size, check imgsize was specified, otherwise it'd clear the var 131 if [ ! -z "$imgsize" ]; then 132 rwsize="$(fw_printenv -n rwfs_size 2>/dev/null)" || true 133 if [[ "${imgsize}" != "${rwsize}" ]]; then 134 fw_setenv rwfs_size "${imgsize}" 135 fi 136 fi 137 138 vol="$(findubi "${name}")" 139 if [ -z "${vol}" ]; then 140 ubimkvol "${ubidev}" -N "${name}" -s "${imgsize}" 141 fi 142} 143 144ubi_ro() { 145 keepmax=2 # Default 2 volumes per mtd 146 romtd="$(findmtd "${reqmtd}")" 147 romtd2="$(findmtd "${reqmtd2}")" 148 149 if [ ! "${romtd}" == "${romtd2}" ]; then 150 # Request to use alternate mtd device, choose the non-root one 151 keepmax=1 # 1 volume on each of the requested mtds 152 rootmtd="$(findrootmtd)" 153 if [ "${rootmtd}" == "${romtd}" ]; then 154 romtd="${romtd2}" 155 fi 156 fi 157 ro="${romtd#mtd}" 158 ubidev="/dev/ubi${ro}" 159 160 ubi_remove_volumes 161 162 if [ -z "${imgfile}" ]; then 163 echo "Unable to create read-only volume. Image file not specified." 164 return 1 165 fi 166 167 # Create a ubi volume, dynamically sized to fit BMC image if size unspecified 168 img="/tmp/images/${version}/${imgfile}" 169 imgsize="$(stat -c '%s' ${img})" 170 171 vol="$(findubi "${name}")" 172 if [ ! -z "${vol}" ]; then 173 # Allow a duplicate kernel volume on the alt mtd 174 if [[ "${name}" =~ "kernel" ]]; then 175 vol="$(findubi_onmtd "${name}" "${ro}")" 176 fi 177 fi 178 if [ -z "${vol}" ]; then 179 ubimkvol "${ubidev}" -N "${name}" -s "${imgsize}" --type=static 180 vol="$(findubi "${name}")" 181 fi 182 183 set_flashid "${version}" 184} 185 186# Squashfs images need a ubi block 187ubi_block() { 188 vol="$(findubi "${name}")" 189 ubidevid="${vol#ubi}" 190 block="/dev/ubiblock${ubidevid}" 191 if [ ! -e "$block" ]; then 192 ubiblock --create "/dev/ubi${ubidevid}" 193 fi 194} 195 196ubi_updatevol() { 197 vol="$(findubi "${name}")" 198 ubidevid="${vol#ubi}" 199 img="/tmp/images/${version}/${imgfile}" 200 ubiupdatevol "/dev/ubi${ubidevid}" "${img}" 201} 202 203ubi_remove() { 204 rmname="$1" 205 rmmtd="$2" 206 if [ ! -z "${rmmtd}" ]; then 207 vol="$(findubi_onmtd "${rmname}" "${rmmtd}")" 208 else 209 vol="$(findubi "${rmname}")" 210 fi 211 212 if [ ! -z "$vol" ]; then 213 vol="${vol%_*}" 214 215 if grep -q "$rmname" /proc/mounts; then 216 mountdir=$(grep "$rmname" /proc/mounts | cut -d " " -f 2) 217 umount "$mountdir" 218 rm -r "$mountdir" 219 fi 220 221 ubirmvol "/dev/${vol}" -N "$rmname" 222 fi 223} 224 225ubi_cleanup() { 226 # When ubi_cleanup is run, it expects one or no active version. 227 activeVersion=$(busctl --list --no-pager tree \ 228 xyz.openbmc_project.Software.BMC.Updater | \ 229 grep /xyz/openbmc_project/software/ | tail -c 9) 230 231 if [[ -z "$activeVersion" ]]; then 232 vols=$(ubinfo -a | grep "rofs-" | cut -c 14-) 233 vols=(${vols}) 234 else 235 flashid=$(busctl get-property xyz.openbmc_project.Software.BMC.Updater \ 236 "/xyz/openbmc_project/software/${activeVersion}" \ 237 xyz.openbmc_project.Common.FilePath Path | awk '{print $NF;}' | tr -d '"') 238 vols=$(ubinfo -a | grep "rofs-" | \ 239 grep -v "$flashid" | cut -c 14-) || true 240 vols=(${vols}) 241 fi 242 243 for (( index=0; index<${#vols[@]}; index++ )); do 244 ubi_remove ${vols[index]} 245 done 246} 247 248mount_alt_rwfs() { 249 altNum="$(findmtdnum "alt-bmc")" 250 if [ ! -z "${altNum}" ]; then 251 altRwfs=$(ubinfo -a -d ${altNum} | grep -w "rwfs") || true 252 if [ ! -z "${altRwfs}" ]; then 253 altVarMount="/media/alt/var" 254 mkdir -p "${altVarMount}" 255 if mount ubi"${altNum}":rwfs "${altVarMount}" -t ubifs -o defaults; then 256 mkdir -p "${altVarMount}"/persist/etc 257 fi 258 fi 259 fi 260} 261 262remount_ubi() { 263 bmcmtd="$(findmtd "bmc")" 264 altbmcmtd="$(findmtd "alt-bmc")" 265 mtds="${bmcmtd: -1}","${altbmcmtd: -1}" 266 267 rootubi="$(findrootubi)" 268 rootname="$(findname "${rootubi}")" 269 270 IFS=',' read -r -a mtds <<< "$mtds" 271 mtds=($(echo "${mtds[@]}" | tr ' ' '\n' | sort -u | tr '\n' ' ')) 272 for mtd in ${mtds[@]}; do 273 # Get information on all ubi volumes 274 ubinfo=$(ubinfo -d ${mtd}) 275 presentVolumes=${ubinfo##*:} 276 IFS=', ' read -r -a array <<< "$presentVolumes" 277 for element in ${array[@]}; do 278 elementProperties=$(ubinfo -d $mtd -n $element) 279 # Get ubi volume name by getting rid of additional properties 280 name=${elementProperties#*Name:} 281 name="${name%Character*}" 282 name="$(echo -e "${name}" | tr -d '[:space:]')" 283 284 if [[ ${name} == rofs-* ]]; then 285 if [[ "${name}" == "${rootname}" ]]; then 286 mountdir="/media/${name}-functional" 287 else 288 mountdir="/media/${name}" 289 fi 290 291 if [ ! -d ${mountdir} ]; then 292 mkdir -p "${mountdir}" 293 # U-Boot will create the ubiblock for the running version, but not 294 # for the version on the other chip 295 if [ ! -e "/dev/ubiblock${mtd}_${element}" ]; then 296 ubiblock --create /dev/ubi${mtd}_${element} 297 fi 298 mount -t squashfs -o ro "/dev/ubiblock${mtd}_${element}" "${mountdir}" 299 fi 300 fi 301 done 302 done 303 304 set_wdt2bite 305} 306 307# Read the current env variable and set it on the alternate boot env 308copy_env_var_to_alt() { 309 varName=$1 310 value="$(fw_printenv -n "${varName}")" 311 fw_setenv -c /etc/alt_fw_env.config "${varName}" "${value}" 312} 313 314# When the alternate bmc chip boots, u-boot thinks its the primary mtdX. 315# Therefore need to swap the chip numbers when copying the ubiblock and root to 316# alternate bmc u-boot environment. 317copy_ubiblock_to_alt() { 318 value="$(fw_printenv -n ubiblock)" 319 bmcNum="$(findmtdnum "bmc")" 320 altNum="$(findmtdnum "alt-bmc")" 321 replaceAlt="${value/${altNum},/${bmcNum},}" 322 323 if [[ "${value}" == "${replaceAlt}" ]]; then 324 replaceBmc="${value/${bmcNum},/${altNum},}" 325 value=${replaceBmc} 326 else 327 value=${replaceAlt} 328 fi 329 330 fw_setenv -c /etc/alt_fw_env.config ubiblock "${value}" 331} 332 333copy_root_to_alt() { 334 value="$(fw_printenv -n root)" 335 bmcNum="$(findmtdnum "bmc")" 336 altNum="$(findmtdnum "alt-bmc")" 337 replaceAlt="${value/${altNum}_/${bmcNum}_}" 338 339 if [[ "${value}" == "${replaceAlt}" ]]; then 340 replaceBmc="${value/${bmcNum}_/${altNum}_}" 341 value=${replaceBmc} 342 else 343 value=${replaceAlt} 344 fi 345 346 fw_setenv -c /etc/alt_fw_env.config root "${value}" 347} 348 349ubi_setenv() { 350 # The U-Boot environment maintains two banks of environment variables. 351 # The banks need to be consistent with each other to ensure that these 352 # variables can reliably be read from file. In order to guarantee that the 353 # banks are both correct, we need to run fw_setenv twice. 354 variable=$1 355 if [[ "$variable" == *"="* ]]; then 356 varName="${variable%=*}" 357 value="${variable##*=}" 358 # Write only if var is not set already to the requested value 359 currentValue="$(fw_printenv -n "${varName}" 2>/dev/null)" || true 360 if [[ "${currenValue}" != "${value}" ]]; then 361 fw_setenv "$varName" "$value" 362 fw_setenv "$varName" "$value" 363 fi 364 else 365 fw_setenv "$variable" 366 fw_setenv "$variable" 367 fi 368} 369 370mtd_write() { 371 flashmtd="$(findmtd "${reqmtd}")" 372 img="/tmp/images/${version}/${imgfile}" 373 flashcp -v ${img} /dev/${flashmtd} 374} 375 376backup_env_vars() { 377 copy_env_var_to_alt kernelname 378 copy_ubiblock_to_alt 379 copy_root_to_alt 380} 381 382update_env_vars() { 383 vol="$(findubi rofs-"${flashid}")" 384 if [ -z "${vol}" ]; then 385 return 1 386 fi 387 ubidevid="${vol#ubi}" 388 block="/dev/ubiblock${ubidevid}" 389 if [ ! -e "${block}" ]; then 390 return 1 391 fi 392 ubi_setenv "kernelname=kernel-${flashid}" 393 ubi_setenv "ubiblock=$(echo "${ubidevid}" | sed 's/_/,/')" 394 ubi_setenv "root=${block}" 395} 396 397#TODO: Replace the implementation with systemd-inhibitors lock 398# once systemd/systemd#949 is resolved 399rebootguardenable() { 400 dir="/run/systemd/system/" 401 file="reboot-guard.conf" 402 units=("reboot" "poweroff" "halt") 403 404 for unit in "${units[@]}"; do 405 mkdir -p ${dir}${unit}.target.d 406 echo -e "[Unit]\nRefuseManualStart=yes" >> ${dir}${unit}.target.d/${file} 407 done 408} 409 410#TODO: Replace the implementation with systemd-inhibitors lock 411# once systemd/systemd#949 is resolved 412rebootguarddisable() { 413 dir="/run/systemd/system/" 414 file="reboot-guard.conf" 415 units=("reboot" "poweroff" "halt") 416 417 for unit in "${units[@]}"; do 418 rm -rf ${dir}${unit}.target.d/${file} 419 done 420} 421 422# Create a copy in the alt mtd 423create_vol_in_alt() { 424 alt="alt-bmc" 425 altmtd="$(findmtd "${alt}")" 426 if [ ! -z "${altmtd}" ]; then 427 reqmtd="${alt}" 428 reqmtd2="${alt}" 429 ubi_ro 430 ubi_updatevol 431 fi 432} 433 434# Copy contents of one MTD device to another 435mtd_copy() { 436 in=$1 437 out=$2 438 439 # Must erase MTD first to prevent corruption 440 flash_eraseall "${out}" 441 dd if="${in}" of="${out}" 442} 443 444mirroruboot() { 445 bmc="$(findmtd "u-boot")" 446 bmcdev="/dev/${bmc}" 447 alt="$(findmtd "alt-u-boot")" 448 altdev="/dev/${alt}" 449 450 checksum_bmc="$(md5sum "${bmcdev}")" 451 checksum_bmc="${checksum_bmc% *}" 452 checksum_alt="$(md5sum "${altdev}")" 453 checksum_alt="${checksum_alt% *}" 454 455 if [[ "${checksum_bmc}" != "${checksum_alt}" ]]; then 456 bmcenv="$(findmtd "u-boot-env")" 457 bmcenvdev="/dev/${bmcenv}" 458 altenv="$(findmtd "alt-u-boot-env")" 459 altenvdev="/dev/${altenv}" 460 461 echo "Mirroring U-boot to alt chip" 462 mtd_copy "${bmcdev}" "${altdev}" 463 mtd_copy "${bmcenvdev}" "${altenvdev}" 464 465 copy_ubiblock_to_alt 466 copy_root_to_alt 467 fi 468} 469 470# Compare the device where u-boot resides with an image file. Specify the full 471# path to the device and image file to use for the compare. Print a value of 472# "0" if identical, "1" otherwise. 473cmp_uboot() { 474 device="$1" 475 image="$2" 476 477 # Since the image file can be smaller than the device, copy the device to a 478 # tmp file and write the image file on top, then compare the sum of each. 479 # Use cat / redirection since busybox does not have the conv=notrunc option. 480 tmpFile="$(mktemp /tmp/ubootdev.XXXXXX)" 481 dd if="${device}" of="${tmpFile}" 482 devSum="$(sha256sum ${tmpFile})" 483 cat < "${image}" 1<> "${tmpFile}" 484 imgSum="$(sha256sum ${tmpFile})" 485 rm -f "${tmpFile}" 486 487 if [ "${imgSum}" == "${devSum}" ]; then 488 echo "0"; 489 else 490 echo "1"; 491 fi 492} 493 494# The eMMC partition labels for the kernel and rootfs are boot-a/b and rofs-a/b. 495# Return the label (a or b) for the running partition. 496mmc_get_primary_label() { 497 # Get root device /dev/mmcblkpX 498 rootmatch=" on / " 499 root="$(mount | grep "${rootmatch}")" 500 root="${root%${rootmatch}*}" 501 502 # Find the device label 503 if [[ $(readlink -f /dev/disk/by-partlabel/rofs-a) == "${root}" ]]; then 504 echo "a" 505 elif [[ $(readlink -f /dev/disk/by-partlabel/rofs-b) == "${root}" ]]; then 506 echo "b" 507 else 508 echo "" 509 fi 510} 511 512# The eMMC partition labels for the kernel and rootfs are boot-a/b and rofs-a/b. 513# Return the label (a or b) for the non-running partition. 514mmc_get_secondary_label() { 515 root="$(mmc_get_primary_label)" 516 if [[ "${root}" == "a" ]]; then 517 echo "b" 518 elif [[ "${root}" == "b" ]]; then 519 echo "a" 520 else 521 echo "" 522 fi 523} 524 525mmc_mount() { 526 primaryId="$(mmc_get_primary_label)" 527 secondaryId="$(mmc_get_secondary_label)" 528 529 primaryDir="${mediaDir}/rofs-${primaryId}-functional" 530 secondaryDir="${mediaDir}/rofs-${secondaryId}" 531 532 mkdir -p "${primaryDir}" 533 mkdir -p "${secondaryDir}" 534 535 mount PARTLABEL=rofs-${primaryId} "${primaryDir}" -t ext4 -o ro || rmdir "${primaryDir}" 536 mount PARTLABEL=rofs-${secondaryId} "${secondaryDir}" -t ext4 -o ro || rmdir "${secondaryDir}" 537} 538 539mmc_update() { 540 # Update u-boot if needed 541 bootPartition="mmcblk0boot0" 542 devUBoot="/dev/${bootPartition}" 543 imgUBoot="${imgpath}/${version}/image-u-boot" 544 if [ "$(cmp_uboot "${devUBoot}" "${imgUBoot}")" != "0" ]; then 545 echo 0 > "/sys/block/${bootPartition}/force_ro" 546 dd if="${imgUBoot}" of="${devUBoot}" 547 echo 1 > "/sys/block/${bootPartition}/force_ro" 548 fi 549 550 # Update the secondary (non-running) boot and rofs partitions. 551 label="$(mmc_get_secondary_label)" 552 553 # Update the boot and rootfs partitions, restore their labels after the update 554 # by getting the partition number mmcblk0pX from their label. 555 zstd -d -c ${imgpath}/${version}/image-kernel | dd of="/dev/disk/by-partlabel/boot-${label}" 556 number="$(readlink -f /dev/disk/by-partlabel/boot-${label})" 557 number="${number##*mmcblk0p}" 558 sgdisk --change-name=${number}:boot-${label} /dev/mmcblk0 1>/dev/null 559 560 zstd -d -c ${imgpath}/${version}/image-rofs | dd of="/dev/disk/by-partlabel/rofs-${label}" 561 number="$(readlink -f /dev/disk/by-partlabel/rofs-${label})" 562 number="${number##*mmcblk0p}" 563 sgdisk --change-name=${number}:rofs-${label} /dev/mmcblk0 1>/dev/null 564 565 # Run this after sgdisk for labels to take effect. 566 partprobe 567 568 # Update hostfw 569 if [ -f ${imgpath}/${version}/image-hostfw ]; then 570 # Remove patches 571 patchdir="/usr/local/share/hostfw/alternate" 572 if [ -d "${patchdir}" ]; then 573 rm -rf "${patchdir}"/* 574 fi 575 hostfwdir=$(grep "hostfw " /proc/mounts | cut -d " " -f 2) 576 cp ${imgpath}/${version}/image-hostfw ${hostfwdir}/hostfw-${label} 577 mkdir -p ${hostfwdir}/alternate 578 mount ${hostfwdir}/hostfw-${label} ${hostfwdir}/alternate -o ro 579 fi 580 581 set_flashid "${label}" 582} 583 584mmc_remove() { 585 # Render the filesystem unbootable by wiping out the first 1MB, this 586 # invalidates the filesystem header. 587 # Check if the requested id is the one the BMC is running from since dd 588 # can still write and corrupt the running partition. 589 primaryid="$(mmc_get_primary_label)" 590 if [[ "${flashid}" == "${primaryid}" ]]; then 591 return -1 592 fi 593 dd if=/dev/zero of=/dev/disk/by-partlabel/boot-${flashid} count=2048 594 dd if=/dev/zero of=/dev/disk/by-partlabel/rofs-${flashid} count=2048 595 596 hostfw_alt="hostfw/alternate" 597 if grep -q "${hostfw_alt}" /proc/mounts; then 598 hostfw_alt=$(grep "${hostfw_alt}" /proc/mounts | cut -d " " -f 2) 599 umount "${hostfw_alt}" 600 fi 601 hostfw_base="hostfw " 602 if grep -q "${hostfw_base}" /proc/mounts; then 603 hostfw_base=$(grep "${hostfw_base}" /proc/mounts | cut -d " " -f 2) 604 rm -f ${hostfw_base}/hostfw-${flashid} 605 fi 606} 607 608# Set the requested version as primary for the BMC to boot from upon reboot. 609mmc_setprimary() { 610 # Point root to the flashid of the requested BMC rootfs. 611 fw_setenv bootside "${flashid}" 612} 613 614case "$1" in 615 mtduboot) 616 reqmtd="$2" 617 version="$3" 618 imgfile="image-u-boot" 619 mtd_write 620 ;; 621 ubirw) 622 reqmtd="$2" 623 name="$3" 624 imgsize="$4" 625 ubi_rw 626 ;; 627 ubiro) 628 reqmtd="$(echo "$2" | cut -d "+" -f 1)" 629 reqmtd2="$(echo "$2" | cut -d "+" -f 2)" 630 name="$3" 631 version="$4" 632 imgfile="image-rofs" 633 ubi_ro 634 ubi_updatevol 635 ubi_block 636 ;; 637 ubikernel) 638 reqmtd="$(echo "$2" | cut -d "+" -f 1)" 639 reqmtd2="$(echo "$2" | cut -d "+" -f 2)" 640 name="$3" 641 version="$4" 642 imgfile="image-kernel" 643 ubi_ro 644 ubi_updatevol 645 create_vol_in_alt 646 ;; 647 ubiremove) 648 name="$2" 649 ubi_remove "${name}" 650 ;; 651 ubicleanup) 652 ubi_cleanup 653 ;; 654 ubisetenv) 655 ubi_setenv "$2" 656 ;; 657 ubiremount) 658 remount_ubi 659 mount_alt_rwfs 660 ;; 661 createenvbackup) 662 backup_env_vars 663 ;; 664 updateubootvars) 665 flashid="$2" 666 update_env_vars 667 ;; 668 rebootguardenable) 669 rebootguardenable 670 ;; 671 rebootguarddisable) 672 rebootguarddisable 673 ;; 674 mirroruboot) 675 mirroruboot 676 ;; 677 mmc) 678 version="$2" 679 imgpath="$3" 680 mmc_update 681 ;; 682 mmc-mount) 683 mediaDir="$2" 684 mmc_mount 685 ;; 686 mmc-remove) 687 flashid="$2" 688 mmc_remove 689 ;; 690 mmc-setprimary) 691 flashid="$2" 692 mmc_setprimary 693 ;; 694 *) 695 echo "Invalid argument" 696 exit 1 697 ;; 698esac 699