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_ubi_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 307mount_static_alt() { 308 typ=$1 309 altFs=$2 310 mountName=$3 311 altNum="$(findmtdnum ${altFs})" 312 if [ ! -z "${altNum}" ]; then 313 altFsMount="/run/media/${mountName}" 314 mkdir -p "${altFsMount}" 315 altFsBlock="/dev/mtdblock${altNum}" 316 mount -t "${typ}" "${altFsBlock}" "${altFsMount}" 317 fi 318} 319 320umount_static_alt() { 321 altFs=$1 322 altFsMount="/run/media/${altFs}" 323 umount "${altFsMount}" 324} 325 326# Read the current env variable and set it on the alternate boot env 327copy_env_var_to_alt() { 328 varName=$1 329 value="$(fw_printenv -n "${varName}")" 330 fw_setenv -c /etc/alt_fw_env.config "${varName}" "${value}" 331} 332 333# When the alternate bmc chip boots, u-boot thinks its the primary mtdX. 334# Therefore need to swap the chip numbers when copying the ubiblock and root to 335# alternate bmc u-boot environment. 336copy_ubiblock_to_alt() { 337 value="$(fw_printenv -n ubiblock)" 338 bmcNum="$(findmtdnum "bmc")" 339 altNum="$(findmtdnum "alt-bmc")" 340 replaceAlt="${value/${altNum},/${bmcNum},}" 341 342 if [[ "${value}" == "${replaceAlt}" ]]; then 343 replaceBmc="${value/${bmcNum},/${altNum},}" 344 value=${replaceBmc} 345 else 346 value=${replaceAlt} 347 fi 348 349 fw_setenv -c /etc/alt_fw_env.config ubiblock "${value}" 350} 351 352copy_root_to_alt() { 353 value="$(fw_printenv -n root)" 354 bmcNum="$(findmtdnum "bmc")" 355 altNum="$(findmtdnum "alt-bmc")" 356 replaceAlt="${value/${altNum}_/${bmcNum}_}" 357 358 if [[ "${value}" == "${replaceAlt}" ]]; then 359 replaceBmc="${value/${bmcNum}_/${altNum}_}" 360 value=${replaceBmc} 361 else 362 value=${replaceAlt} 363 fi 364 365 fw_setenv -c /etc/alt_fw_env.config root "${value}" 366} 367 368ubi_setenv() { 369 # The U-Boot environment maintains two banks of environment variables. 370 # The banks need to be consistent with each other to ensure that these 371 # variables can reliably be read from file. In order to guarantee that the 372 # banks are both correct, we need to run fw_setenv twice. 373 variable=$1 374 if [[ "$variable" == *"="* ]]; then 375 varName="${variable%=*}" 376 value="${variable##*=}" 377 # Write only if var is not set already to the requested value 378 currentValue="$(fw_printenv -n "${varName}" 2>/dev/null)" || true 379 if [[ "${currenValue}" != "${value}" ]]; then 380 fw_setenv "$varName" "$value" 381 fw_setenv "$varName" "$value" 382 fi 383 else 384 fw_setenv "$variable" 385 fw_setenv "$variable" 386 fi 387} 388 389mtd_write() { 390 flashmtd="$(findmtd "${reqmtd}")" 391 img="/tmp/images/${version}/${imgfile}" 392 flashcp -v ${img} /dev/${flashmtd} 393} 394 395backup_env_vars() { 396 copy_env_var_to_alt kernelname 397 copy_ubiblock_to_alt 398 copy_root_to_alt 399} 400 401update_env_vars() { 402 vol="$(findubi rofs-"${flashid}")" 403 if [ -z "${vol}" ]; then 404 return 1 405 fi 406 ubidevid="${vol#ubi}" 407 block="/dev/ubiblock${ubidevid}" 408 if [ ! -e "${block}" ]; then 409 return 1 410 fi 411 ubi_setenv "kernelname=kernel-${flashid}" 412 ubi_setenv "ubiblock=$(echo "${ubidevid}" | sed 's/_/,/')" 413 ubi_setenv "root=${block}" 414} 415 416#TODO: Replace the implementation with systemd-inhibitors lock 417# once systemd/systemd#949 is resolved 418rebootguardenable() { 419 dir="/run/systemd/system/" 420 file="reboot-guard.conf" 421 units=("reboot" "poweroff" "halt") 422 423 for unit in "${units[@]}"; do 424 mkdir -p ${dir}${unit}.target.d 425 echo -e "[Unit]\nRefuseManualStart=yes" >> ${dir}${unit}.target.d/${file} 426 done 427} 428 429#TODO: Replace the implementation with systemd-inhibitors lock 430# once systemd/systemd#949 is resolved 431rebootguarddisable() { 432 dir="/run/systemd/system/" 433 file="reboot-guard.conf" 434 units=("reboot" "poweroff" "halt") 435 436 for unit in "${units[@]}"; do 437 rm -rf ${dir}${unit}.target.d/${file} 438 done 439} 440 441# Create a copy in the alt mtd 442create_vol_in_alt() { 443 alt="alt-bmc" 444 altmtd="$(findmtd "${alt}")" 445 if [ ! -z "${altmtd}" ]; then 446 reqmtd="${alt}" 447 reqmtd2="${alt}" 448 ubi_ro 449 ubi_updatevol 450 fi 451} 452 453# Copy contents of one MTD device to another 454mtd_copy() { 455 in=$1 456 out=$2 457 458 # Must erase MTD first to prevent corruption 459 flash_eraseall "${out}" 460 dd if="${in}" of="${out}" 461} 462 463mirroruboot() { 464 bmc="$(findmtd "u-boot")" 465 bmcdev="/dev/${bmc}" 466 alt="$(findmtd "alt-u-boot")" 467 altdev="/dev/${alt}" 468 469 checksum_bmc="$(md5sum "${bmcdev}")" 470 checksum_bmc="${checksum_bmc% *}" 471 checksum_alt="$(md5sum "${altdev}")" 472 checksum_alt="${checksum_alt% *}" 473 474 if [[ "${checksum_bmc}" != "${checksum_alt}" ]]; then 475 bmcenv="$(findmtd "u-boot-env")" 476 bmcenvdev="/dev/${bmcenv}" 477 altenv="$(findmtd "alt-u-boot-env")" 478 altenvdev="/dev/${altenv}" 479 480 echo "Mirroring U-boot to alt chip" 481 mtd_copy "${bmcdev}" "${altdev}" 482 mtd_copy "${bmcenvdev}" "${altenvdev}" 483 484 copy_ubiblock_to_alt 485 copy_root_to_alt 486 fi 487} 488 489# Compare the device where u-boot resides with an image file. Specify the full 490# path to the device and image file to use for the compare. Print a value of 491# "0" if identical, "1" otherwise. 492cmp_uboot() { 493 device="$1" 494 image="$2" 495 496 # Since the image file can be smaller than the device, copy the device to a 497 # tmp file and write the image file on top, then compare the sum of each. 498 # Use cat / redirection since busybox does not have the conv=notrunc option. 499 tmpFile="$(mktemp /tmp/ubootdev.XXXXXX)" 500 dd if="${device}" of="${tmpFile}" 501 devSum="$(sha256sum ${tmpFile})" 502 cat < "${image}" 1<> "${tmpFile}" 503 imgSum="$(sha256sum ${tmpFile})" 504 rm -f "${tmpFile}" 505 506 if [ "${imgSum}" == "${devSum}" ]; then 507 echo "0"; 508 else 509 echo "1"; 510 fi 511} 512 513# The eMMC partition labels for the kernel and rootfs are boot-a/b and rofs-a/b. 514# Return the label (a or b) for the running partition. 515mmc_get_primary_label() { 516 # Get root device /dev/mmcblkpX 517 rootmatch=" on / " 518 root="$(mount | grep "${rootmatch}")" 519 root="${root%${rootmatch}*}" 520 521 # Find the device label 522 if [[ $(readlink -f /dev/disk/by-partlabel/rofs-a) == "${root}" ]]; then 523 echo "a" 524 elif [[ $(readlink -f /dev/disk/by-partlabel/rofs-b) == "${root}" ]]; then 525 echo "b" 526 else 527 echo "" 528 fi 529} 530 531# The eMMC partition labels for the kernel and rootfs are boot-a/b and rofs-a/b. 532# Return the label (a or b) for the non-running partition. 533mmc_get_secondary_label() { 534 root="$(mmc_get_primary_label)" 535 if [[ "${root}" == "a" ]]; then 536 echo "b" 537 elif [[ "${root}" == "b" ]]; then 538 echo "a" 539 else 540 echo "" 541 fi 542} 543 544mmc_mount() { 545 primaryId="$(mmc_get_primary_label)" 546 secondaryId="$(mmc_get_secondary_label)" 547 548 primaryDir="${mediaDir}/rofs-${primaryId}-functional" 549 secondaryDir="${mediaDir}/rofs-${secondaryId}" 550 551 mkdir -p "${primaryDir}" 552 mkdir -p "${secondaryDir}" 553 554 mount PARTLABEL=rofs-${primaryId} "${primaryDir}" -t ext4 -o ro || rmdir "${primaryDir}" 555 mount PARTLABEL=rofs-${secondaryId} "${secondaryDir}" -t ext4 -o ro || rmdir "${secondaryDir}" 556} 557 558mmc_update() { 559 # Update u-boot if needed 560 bootPartition="mmcblk0boot0" 561 devUBoot="/dev/${bootPartition}" 562 imgUBoot="${imgpath}/${version}/image-u-boot" 563 if [ "$(cmp_uboot "${devUBoot}" "${imgUBoot}")" != "0" ]; then 564 echo 0 > "/sys/block/${bootPartition}/force_ro" 565 dd if="${imgUBoot}" of="${devUBoot}" 566 echo 1 > "/sys/block/${bootPartition}/force_ro" 567 fi 568 569 # Update the secondary (non-running) boot and rofs partitions. 570 label="$(mmc_get_secondary_label)" 571 572 # Update the boot and rootfs partitions, restore their labels after the update 573 # by getting the partition number mmcblk0pX from their label. 574 zstd -d -c ${imgpath}/${version}/image-kernel | dd of="/dev/disk/by-partlabel/boot-${label}" 575 number="$(readlink -f /dev/disk/by-partlabel/boot-${label})" 576 number="${number##*mmcblk0p}" 577 sgdisk --change-name=${number}:boot-${label} /dev/mmcblk0 1>/dev/null 578 579 zstd -d -c ${imgpath}/${version}/image-rofs | dd of="/dev/disk/by-partlabel/rofs-${label}" 580 number="$(readlink -f /dev/disk/by-partlabel/rofs-${label})" 581 number="${number##*mmcblk0p}" 582 sgdisk --change-name=${number}:rofs-${label} /dev/mmcblk0 1>/dev/null 583 584 # Run this after sgdisk for labels to take effect. 585 partprobe 586 587 # Update hostfw 588 if [ -f ${imgpath}/${version}/image-hostfw ]; then 589 # Remove patches 590 patchdir="/usr/local/share/hostfw/alternate" 591 if [ -d "${patchdir}" ]; then 592 rm -rf "${patchdir}"/* 593 fi 594 hostfwdir=$(grep "hostfw " /proc/mounts | cut -d " " -f 2) 595 cp ${imgpath}/${version}/image-hostfw ${hostfwdir}/hostfw-${label} 596 mkdir -p ${hostfwdir}/alternate 597 mount ${hostfwdir}/hostfw-${label} ${hostfwdir}/alternate -o ro 598 fi 599 600 set_flashid "${label}" 601} 602 603mmc_remove() { 604 # Render the filesystem unbootable by wiping out the first 1MB, this 605 # invalidates the filesystem header. 606 # Check if the requested id is the one the BMC is running from since dd 607 # can still write and corrupt the running partition. 608 primaryid="$(mmc_get_primary_label)" 609 if [[ "${flashid}" == "${primaryid}" ]]; then 610 return -1 611 fi 612 dd if=/dev/zero of=/dev/disk/by-partlabel/boot-${flashid} count=2048 613 dd if=/dev/zero of=/dev/disk/by-partlabel/rofs-${flashid} count=2048 614 615 hostfw_alt="hostfw/alternate" 616 if grep -q "${hostfw_alt}" /proc/mounts; then 617 hostfw_alt=$(grep "${hostfw_alt}" /proc/mounts | cut -d " " -f 2) 618 umount "${hostfw_alt}" 619 fi 620 hostfw_base="hostfw " 621 if grep -q "${hostfw_base}" /proc/mounts; then 622 hostfw_base=$(grep "${hostfw_base}" /proc/mounts | cut -d " " -f 2) 623 rm -f ${hostfw_base}/hostfw-${flashid} 624 fi 625} 626 627# Set the requested version as primary for the BMC to boot from upon reboot. 628mmc_setprimary() { 629 # Point root to the flashid of the requested BMC rootfs. 630 fw_setenv bootside "${flashid}" 631} 632 633case "$1" in 634 mtduboot) 635 reqmtd="$2" 636 version="$3" 637 imgfile="image-u-boot" 638 mtd_write 639 ;; 640 ubirw) 641 reqmtd="$2" 642 name="$3" 643 imgsize="$4" 644 ubi_rw 645 ;; 646 ubiro) 647 reqmtd="$(echo "$2" | cut -d "+" -f 1)" 648 reqmtd2="$(echo "$2" | cut -d "+" -f 2)" 649 name="$3" 650 version="$4" 651 imgfile="image-rofs" 652 ubi_ro 653 ubi_updatevol 654 ubi_block 655 ;; 656 ubikernel) 657 reqmtd="$(echo "$2" | cut -d "+" -f 1)" 658 reqmtd2="$(echo "$2" | cut -d "+" -f 2)" 659 name="$3" 660 version="$4" 661 imgfile="image-kernel" 662 ubi_ro 663 ubi_updatevol 664 create_vol_in_alt 665 ;; 666 ubiremove) 667 name="$2" 668 ubi_remove "${name}" 669 ;; 670 ubicleanup) 671 ubi_cleanup 672 ;; 673 ubisetenv) 674 ubi_setenv "$2" 675 ;; 676 ubiremount) 677 remount_ubi 678 mount_ubi_alt_rwfs 679 ;; 680 createenvbackup) 681 backup_env_vars 682 ;; 683 updateubootvars) 684 flashid="$2" 685 update_env_vars 686 ;; 687 rebootguardenable) 688 rebootguardenable 689 ;; 690 rebootguarddisable) 691 rebootguarddisable 692 ;; 693 mirroruboot) 694 mirroruboot 695 ;; 696 mmc) 697 version="$2" 698 imgpath="$3" 699 mmc_update 700 ;; 701 mmc-mount) 702 mediaDir="$2" 703 mmc_mount 704 ;; 705 mmc-remove) 706 flashid="$2" 707 mmc_remove 708 ;; 709 mmc-setprimary) 710 flashid="$2" 711 mmc_setprimary 712 ;; 713 static-altfs) 714 mount_static_alt "$2" "$3" "$4" 715 ;; 716 umount-static-altfs) 717 umount_static_alt "$2" 718 ;; 719 *) 720 echo "Invalid argument" 721 exit 1 722 ;; 723esac 724