package/base-files/files/lib/upgrade/nand.sh

   1 # Copyright (C) 2014 OpenWrt.org
   2 #
   3
   4 . /lib/functions.sh
   5
   6 # 'kernel' partition or UBI volume on NAND contains the kernel
   7 CI_KERNPART="${CI_KERNPART:-kernel}"
   8
   9 # 'ubi' partition on NAND contains UBI
  10 CI_UBIPART="${CI_UBIPART:-ubi}"
  11
  12 # 'rootfs' UBI volume on NAND contains the rootfs
  13 CI_ROOTPART="${CI_ROOTPART:-rootfs}"
  14
  15 ubi_mknod() {
  16         local dir="$1"
  17         local dev="/dev/$(basename $dir)"
  18
  19         [ -e "$dev" ] && return 0
  20
  21         local devid="$(cat $dir/dev)"
  22         local major="${devid%%:*}"
  23         local minor="${devid##*:}"
  24         mknod "$dev" c $major $minor
  25 }
  26
  27 nand_find_volume() {
  28         local ubidevdir ubivoldir
  29         ubidevdir="/sys/devices/virtual/ubi/$1"
  30         [ ! -d "$ubidevdir" ] && return 1
  31         for ubivoldir in $ubidevdir/${1}_*; do
  32                 [ ! -d "$ubivoldir" ] && continue
  33                 if [ "$( cat $ubivoldir/name )" = "$2" ]; then
  34                         basename $ubivoldir
  35                         ubi_mknod "$ubivoldir"
  36                         return 0
  37                 fi
  38         done
  39 }
  40
  41 nand_find_ubi() {
  42         local ubidevdir ubidev mtdnum
  43         mtdnum="$( find_mtd_index $1 )"
  44         [ ! "$mtdnum" ] && return 1
  45         for ubidevdir in /sys/devices/virtual/ubi/ubi*; do
  46                 [ ! -d "$ubidevdir" ] && continue
  47                 cmtdnum="$( cat $ubidevdir/mtd_num )"
  48                 [ ! "$mtdnum" ] && continue
  49                 if [ "$mtdnum" = "$cmtdnum" ]; then
  50                         ubidev=$( basename $ubidevdir )
  51                         ubi_mknod "$ubidevdir"
  52                         echo $ubidev
  53                         return 0
  54                 fi
  55         done
  56 }
  57
  58 nand_get_magic_long() {
  59         dd if="$1" skip=$2 bs=4 count=1 2>/dev/null | hexdump -v -n 4 -e '1/1 "%02x"'
  60 }
  61
  62 get_magic_long_tar() {
  63         ( tar xf $1 $2 -O | dd bs=4 count=1 | hexdump -v -n 4 -e '1/1 "%02x"') 2> /dev/null
  64 }
  65
  66 identify_magic() {
  67         local magic=$1
  68         case "$magic" in
  69                 "55424923")
  70                         echo "ubi"
  71                         ;;
  72                 "31181006")
  73                         echo "ubifs"
  74                         ;;
  75                 "68737173")
  76                         echo "squashfs"
  77                         ;;
  78                 "d00dfeed")
  79                         echo "fit"
  80                         ;;
  81                 "4349"*)
  82                         echo "combined"
  83                         ;;
  84                 *)
  85                         echo "unknown $magic"
  86                         ;;
  87         esac
  88 }
  89
  90
  91 identify() {
  92         identify_magic $(nand_get_magic_long "$1" "${2:-0}")
  93 }
  94
  95 identify_tar() {
  96         identify_magic $(get_magic_long_tar "$1" "$2")
  97 }
  98
  99 nand_restore_config() {
 100         sync
 101         local ubidev=$( nand_find_ubi $CI_UBIPART )
 102         local ubivol="$( nand_find_volume $ubidev rootfs_data )"
 103         [ ! "$ubivol" ] &&
 104                 ubivol="$( nand_find_volume $ubidev $CI_ROOTPART )"
 105         mkdir /tmp/new_root
 106         if ! mount -t ubifs /dev/$ubivol /tmp/new_root; then
 107                 echo "mounting ubifs $ubivol failed"
 108                 rmdir /tmp/new_root
 109                 return 1
 110         fi
 111         mv "$1" "/tmp/new_root/$BACKUP_FILE"
 112         umount /tmp/new_root
 113         sync
 114         rmdir /tmp/new_root
 115 }
 116
 117 nand_upgrade_prepare_ubi() {
 118         local rootfs_length="$1"
 119         local rootfs_type="$2"
 120         local rootfs_data_max="$(fw_printenv -n rootfs_data_max 2>/dev/null)"
 121         [ -n "$rootfs_data_max" ] && rootfs_data_max=$((rootfs_data_max))
 122
 123         local kernel_length="$3"
 124         local has_env="${4:-0}"
 125
 126         [ -n "$rootfs_length" -o -n "$kernel_length" ] || return 1
 127
 128         local mtdnum="$( find_mtd_index "$CI_UBIPART" )"
 129         if [ ! "$mtdnum" ]; then
 130                 echo "cannot find ubi mtd partition $CI_UBIPART"
 131                 return 1
 132         fi
 133
 134         local ubidev="$( nand_find_ubi "$CI_UBIPART" )"
 135         if [ ! "$ubidev" ]; then
 136                 ubiattach -m "$mtdnum"
 137                 sync
 138                 ubidev="$( nand_find_ubi "$CI_UBIPART" )"
 139         fi
 140
 141         if [ ! "$ubidev" ]; then
 142                 ubiformat /dev/mtd$mtdnum -y
 143                 ubiattach -m "$mtdnum"
 144                 sync
 145                 ubidev="$( nand_find_ubi "$CI_UBIPART" )"
 146                 [ ! "$ubidev" ] && return 1
 147                 [ "$has_env" -gt 0 ] && {
 148                         ubimkvol /dev/$ubidev -n 0 -N ubootenv -s 1MiB
 149                         ubimkvol /dev/$ubidev -n 1 -N ubootenv2 -s 1MiB
 150                 }
 151         fi
 152
 153         local kern_ubivol="$( nand_find_volume $ubidev $CI_KERNPART )"
 154         local root_ubivol="$( nand_find_volume $ubidev $CI_ROOTPART )"
 155         local data_ubivol="$( nand_find_volume $ubidev rootfs_data )"
 156
 157         local ubiblk ubiblkvol
 158         for ubiblk in /dev/ubiblock${ubidev:3}_* ; do
 159                 [ -e "$ubiblk" ] || continue
 160                 case "$ubiblk" in
 161                 /dev/ubiblock*_*p*)
 162                         continue
 163                         ;;
 164                 esac
 165                 echo "removing ubiblock${ubiblk:13}"
 166                 ubiblkvol=ubi${ubiblk:13}
 167                 if ! ubiblock -r /dev/$ubiblkvol; then
 168                         echo "cannot remove $ubiblk"
 169                         return 1
 170                 fi
 171         done
 172
 173         # kill volumes
 174         [ "$kern_ubivol" ] && ubirmvol /dev/$ubidev -N $CI_KERNPART || :
 175         [ "$root_ubivol" -a "$root_ubivol" != "$kern_ubivol" ] && ubirmvol /dev/$ubidev -N $CI_ROOTPART || :
 176         [ "$data_ubivol" ] && ubirmvol /dev/$ubidev -N rootfs_data || :
 177
 178         # update kernel
 179         if [ -n "$kernel_length" ]; then
 180                 if ! ubimkvol /dev/$ubidev -N $CI_KERNPART -s $kernel_length; then
 181                         echo "cannot create kernel volume"
 182                         return 1;
 183                 fi
 184         fi
 185
 186         # update rootfs
 187         if [ -n "$rootfs_length" ]; then
 188                 local rootfs_size_param
 189                 if [ "$rootfs_type" = "ubifs" ]; then
 190                         rootfs_size_param="-m"
 191                 else
 192                         rootfs_size_param="-s $rootfs_length"
 193                 fi
 194                 if ! ubimkvol /dev/$ubidev -N $CI_ROOTPART $rootfs_size_param; then
 195                         echo "cannot create rootfs volume"
 196                         return 1;
 197                 fi
 198         fi
 199
 200         # create rootfs_data for non-ubifs rootfs
 201         if [ "$rootfs_type" != "ubifs" ]; then
 202                 local rootfs_data_size_param="-m"
 203                 if [ -n "$rootfs_data_max" ]; then
 204                         rootfs_data_size_param="-s $rootfs_data_max"
 205                 fi
 206                 if ! ubimkvol /dev/$ubidev -N rootfs_data $rootfs_data_size_param; then
 207                         if ! ubimkvol /dev/$ubidev -N rootfs_data -m; then
 208                                 echo "cannot initialize rootfs_data volume"
 209                                 return 1
 210                         fi
 211                 fi
 212         fi
 213         sync
 214         return 0
 215 }
 216
 217 nand_do_upgrade_success() {
 218         local conf_tar="/tmp/sysupgrade.tgz"
 219
 220         sync
 221         [ -f "$conf_tar" ] && nand_restore_config "$conf_tar"
 222         echo "sysupgrade successful"
 223         umount -a
 224         reboot -f
 225 }
 226
 227 # Flash the UBI image to MTD partition
 228 nand_upgrade_ubinized() {
 229         local ubi_file="$1"
 230         local mtdnum="$(find_mtd_index "$CI_UBIPART")"
 231
 232         [ ! "$mtdnum" ] && {
 233                 CI_UBIPART="rootfs"
 234                 mtdnum="$(find_mtd_index "$CI_UBIPART")"
 235         }
 236
 237         if [ ! "$mtdnum" ]; then
 238                 echo "cannot find mtd device $CI_UBIPART"
 239                 umount -a
 240                 reboot -f
 241         fi
 242
 243         local mtddev="/dev/mtd${mtdnum}"
 244         ubidetach -p "${mtddev}" || true
 245         sync
 246         ubiformat "${mtddev}" -y -f "${ubi_file}"
 247         ubiattach -p "${mtddev}"
 248         nand_do_upgrade_success
 249 }
 250
 251 # Write the UBIFS image to UBI volume
 252 nand_upgrade_ubifs() {
 253         local rootfs_length=$( (cat $1 | wc -c) 2> /dev/null)
 254
 255         nand_upgrade_prepare_ubi "$rootfs_length" "ubifs" "" ""
 256
 257         local ubidev="$( nand_find_ubi "$CI_UBIPART" )"
 258         local root_ubivol="$(nand_find_volume $ubidev $CI_ROOTPART)"
 259         ubiupdatevol /dev/$root_ubivol -s $rootfs_length $1
 260
 261         nand_do_upgrade_success
 262 }
 263
 264 nand_upgrade_fit() {
 265         local fit_file="$1"
 266         local fit_length="$(wc -c < "$fit_file")"
 267
 268         nand_upgrade_prepare_ubi "" "" "$fit_length" "1"
 269
 270         local fit_ubidev="$(nand_find_ubi "$CI_UBIPART")"
 271         local fit_ubivol="$(nand_find_volume $fit_ubidev "$CI_KERNPART")"
 272         ubiupdatevol /dev/$fit_ubivol -s $fit_length $fit_file
 273
 274         nand_do_upgrade_success
 275 }
 276
 277 nand_upgrade_tar() {
 278         local tar_file="$1"
 279         local kernel_mtd="$(find_mtd_index $CI_KERNPART)"
 280
 281         local board_dir=$(tar tf "$tar_file" | grep -m 1 '^sysupgrade-.*/$')
 282         board_dir=${board_dir%/}
 283
 284         kernel_length=$( (tar xf "$tar_file" ${board_dir}/kernel -O | wc -c) 2> /dev/null)
 285         local has_rootfs=0
 286         local rootfs_length
 287         local rootfs_type
 288
 289         tar tf "$tar_file" ${board_dir}/root 1>/dev/null 2>/dev/null && has_rootfs=1
 290         [ "$has_rootfs" = "1" ] && {
 291                 rootfs_length=$( (tar xf "$tar_file" ${board_dir}/root -O | wc -c) 2> /dev/null)
 292                 rootfs_type="$(identify_tar "$tar_file" ${board_dir}/root)"
 293         }
 294
 295         local has_kernel=1
 296         local has_env=0
 297
 298         [ "$kernel_length" != 0 -a -n "$kernel_mtd" ] && {
 299                 tar xf "$tar_file" ${board_dir}/kernel -O | mtd write - $CI_KERNPART
 300         }
 301         [ "$kernel_length" = 0 -o ! -z "$kernel_mtd" ] && has_kernel=
 302         [ "$CI_KERNPART" = "none" ] && has_kernel=
 303
 304         nand_upgrade_prepare_ubi "$rootfs_length" "$rootfs_type" "${has_kernel:+$kernel_length}" "$has_env"
 305
 306         local ubidev="$( nand_find_ubi "$CI_UBIPART" )"
 307         [ "$has_kernel" = "1" ] && {
 308                 local kern_ubivol="$( nand_find_volume $ubidev $CI_KERNPART )"
 309                 tar xf "$tar_file" ${board_dir}/kernel -O | \
 310                         ubiupdatevol /dev/$kern_ubivol -s $kernel_length -
 311         }
 312
 313         [ "$has_rootfs" = "1" ] && {
 314                 local root_ubivol="$( nand_find_volume $ubidev $CI_ROOTPART )"
 315                 tar xf "$tar_file" ${board_dir}/root -O | \
 316                         ubiupdatevol /dev/$root_ubivol -s $rootfs_length -
 317         }
 318         nand_do_upgrade_success
 319 }
 320
 321 # Recognize type of passed file and start the upgrade process
 322 nand_do_upgrade() {
 323         local file_type=$(identify $1)
 324
 325         [ ! "$(find_mtd_index "$CI_UBIPART")" ] && CI_UBIPART="rootfs"
 326
 327         case "$file_type" in
 328                 "fit")          nand_upgrade_fit $1;;
 329                 "ubi")          nand_upgrade_ubinized $1;;
 330                 "ubifs")        nand_upgrade_ubifs $1;;
 331                 *)              nand_upgrade_tar $1;;
 332         esac
 333 }
 334
 335 # Check if passed file is a valid one for NAND sysupgrade. Currently it accepts
 336 # 3 types of files:
 337 # 1) UBI - should contain an ubinized image, header is checked for the proper
 338 #    MAGIC
 339 # 2) UBIFS - should contain UBIFS partition that will replace "rootfs" volume,
 340 #    header is checked for the proper MAGIC
 341 # 3) TAR - archive has to include "sysupgrade-BOARD" directory with a non-empty
 342 #    "CONTROL" file (at this point its content isn't verified)
 343 #
 344 # You usually want to call this function in platform_check_image.
 345 #
 346 # $(1): board name, used in case of passing TAR file
 347 # $(2): file to be checked
 348 nand_do_platform_check() {
 349         local board_name="$1"
 350         local tar_file="$2"
 351         local control_length=$( (tar xf $tar_file sysupgrade-$board_name/CONTROL -O | wc -c) 2> /dev/null)
 352         local file_type="$(identify $2)"
 353
 354         [ "$control_length" = 0 -a "$file_type" != "ubi" -a "$file_type" != "ubifs" -a "$file_type" != "fit" ] && {
 355                 echo "Invalid sysupgrade file."
 356                 return 1
 357         }
 358
 359         return 0
 360 }