Rename options names to be more descriptive

Issues: MEN-2162

Changelog: None

Signed-off-by: Adam Podogrocki <a.podogrocki@gmail.com>

bbb-convert-stage-5.sh

@@ -3,23 +3,26 @@
 show_help() {
 cat << EOF
 
-Tool adding GRUB specific files to Mender compliant .sdimg image file.
+Tool adding GRUB specific files to Mender compliant image file.
 
 Usage: $0 [options]
 
-    Options: [-i|--image | -t|--toolchain -k|--keep | -d|--device-type]
+    Options: [-m|--mender-disk-image | -b|--bootloader-toolchain |
+              -k|--keep | -d|--device-type]
 
-        --image        - .sdimg image generated with mender-convert
-        --toolchain    - ARM specific toolchain path
-        --keep         - prevent deleting GRUB workspace
+        --mender-disk-image    - Mender raw disk image
+        --bootloader-toolchain - GNU Arm Embedded Toolchain
         --device-type          - target device type identification
+        --keep                 - prevent deleting GRUB workspace
 
     Note: supported device types are: beaglebone, raspberrypi3
 
     Examples:
 
-        ./mender-convert.sh install_bootloader --image <sdimg_file_path>
-                --device-type beaglebone --toolchain arm-linux-gnueabihf
+        ./mender-convert.sh install-bootloader-to-mender-disk-image
+                --mender-disk-image <mender_image_path>
+                --device-type <beaglebone | raspberrypi3>
+                --bootloader-toolchain arm-linux-gnueabihf
 
         Note: toolchain naming convention is arch-vendor-(os-)abi
 
@@ -35,14 +38,14 @@ tool_dir="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
 output_dir=${tool_dir}/output
 grubenv_dir=$output_dir/grubenv
 grubenv_build_dir=$output_dir/grubenv_build
-image=
-toolchain=
+mender_disk_image=
+bootloader_toolchain=
 device_type=
 keep=0
 efi_boot=EFI/BOOT
 EFI_STUB_VER="4.12.0"
 
-declare -a sdimgmappings
+declare -a mender_disk_mappings
 
 version() {
   echo "$@" | awk -F. '{ printf("%d%03d%03d%03d\n", $1,$2,$3,$4); }'
@@ -115,11 +118,11 @@ build_grub_efi() {
   mkdir -p $grub_build
   # Build GRUB tools (grub-mkimage) and ARM modules in one step
   ./autogen.sh
-  ./configure --host=x86_64-linux-gnu TARGET_CC=${toolchain}-gcc \
-     TARGET_OBJCOPY=${toolchain}-objcopy \
-     TARGET_STRIP=${toolchain}-strip \
-     TARGET_NM=${toolchain}-nm \
-     TARGET_RANLIB=${toolchain}-ranlib \
+  ./configure --host=x86_64-linux-gnu TARGET_CC=${bootloader_toolchain}-gcc \
+     TARGET_OBJCOPY=${bootloader_toolchain}-objcopy \
+     TARGET_STRIP=${bootloader_toolchain}-strip \
+     TARGET_NM=${bootloader_toolchain}-nm \
+     TARGET_RANLIB=${bootloader_toolchain}-ranlib \
      --target=arm --with-platform=efi --exec-prefix=$grub_build \
      --prefix=$grub_build --disable-werror
 
@@ -190,13 +193,13 @@ install_files() {
 do_install_bootloader() {
   echo "Setting bootloader..."
 
-  if [ -z "${image}" ]; then
-    echo ".sdimg image file not set. Aborting."
+  if [ -z "${mender_disk_image}" ]; then
+    echo "Mender raw disk image not set. Aborting."
     exit 1
   fi
 
-  if [ -z "${toolchain}" ]; then
-    echo "ARM toolchain not set. Aborting."
+  if [ -z "${bootloader_toolchain}" ]; then
+    echo "ARM GCC toolchain not set. Aborting."
     exit 1
   fi    
 
@@ -205,20 +208,21 @@ do_install_bootloader() {
     exit 1
   fi
 
-  if [[ $(which ${toolchain}-gcc) = 1 ]]; then
+  if [[ $(which ${bootloader_toolchain}-gcc) = 1 ]]; then
     echo "Error: ARM GCC not found in PATH. Aborting."
     exit 1
   fi
 
-  [ ! -f $image ] && { echo "$image - file not found. Aborting."; exit 1; }
+  [ ! -f $mender_disk_image ] && \
+      { echo "$mender_disk_image - file not found. Aborting."; exit 1; }
 
   # Map & mount Mender compliant image.
-  create_device_maps $image sdimgmappings
+  create_device_maps $mender_disk_image mender_disk_mappings
 
   mkdir -p $output_dir && cd $output_dir
 
-  boot=${sdimgmappings[0]}
-  primary=${sdimgmappings[1]}
+  boot=${mender_disk_mappings[0]}
+  primary=${mender_disk_mappings[1]}
   map_boot=/dev/mapper/"$boot"
   map_primary=/dev/mapper/"$primary"
   path_boot=$output_dir/sdimg/boot
@@ -243,7 +247,7 @@ do_install_bootloader() {
   # Back to working directory.
   cd $tool_dir && sync
 
-  detach_device_maps ${sdimgmappings[@]}
+  detach_device_maps ${mender_disk_mappings[@]}
   # Clean files.
   rm -rf $output_dir/sdimg
 
@@ -255,12 +259,12 @@ PARAMS=""
 
 while (( "$#" )); do
   case "$1" in
-    -i | --image)
-      image=$2
+    -m | --mender-disk-image)
+      mender_disk_image=$2
       shift 2
       ;;
-    -t | --toolchain)
-      toolchain=$2
+    -b | --bootloader-toolchain)
+      bootloader_toolchain=$2
       shift 2
       ;;
     -d | --device-type)

convert-stage-4.sh

@@ -7,22 +7,26 @@ Mender executables, service and configuration files installer.
 
 Usage: $0 [options]
 
-    Options: [-i|--image | -m|--mender | -a|--artifact | -d|--device-type |
-              -p|--demo-ip | -u| --production-url | -o| --hosted-token]
+    Options: [-m|--mender-disk-image | -g|--mender-client | -a|--artifact-name |
+              -d|--device-type | -p|--demo-host-ip | -u| --server-url |
+              -t| --tenant-token]
 
-        --image          - .sdimg generated with mender-convert tool
-        --mender         - mender client binary file
-        --artifact       - artifact info
+        --mender-disk-image - Mender raw disk image
+        --mender-client     - Mender client binary file
+        --artifact-name     - artifact info
         --device-type       - target device type identification
-        --demo-ip        - Mender demo server IP address
-        --production-url - Mender production server url
-        --certificate    - Mender server certificate
+        --demo-host-ip      - Mender demo server IP address
+        --server-url        - Mender production server url
+        --server-cert       - Mender server certificate
 
     Examples:
 
-        ./mender-convert.sh install_mender --image <sdimg_file_path>
-                --device-type beaglebone --artifact release-1_1.5.0
-                --demo-ip 192.168.10.2 --mender <mender_binary_path>
+        ./mender-convert.sh install-mender-to-mender-disk-image
+                --mender-disk-image <mender_image_path>
+                --device-type <beaglebone | raspberrypi3>
+                --artifact-name release-1_1.5.0
+                --demo-host-ip 192.168.10.2
+                --mender-client <mender_binary_path>
 
 EOF
   exit 1
@@ -38,21 +42,21 @@ meta_mender_revision="sumo"
 
 mender_dir=$output_dir/mender
 device_type=
-artifact=
+artifact_name=
 # Mender demo server IP address.
-demo_ip=
-# Mender production server url.
-production_url=
-# Used server url.
-server_url="https://docker.mender.io"
+demo_host_ip=
+# Mender production server url passed as CLI option.
+server_url=
+# Actual server url.
+mender_server_url="https://docker.mender.io"
 # Mender production certificate.
-certificate=
-# Mender hosted token.
-hosted_token=
+server_cert=
+# Mender tenant token passed as CLI option.
+tenant_token=
 # Mender tenant token.
-tenant_token="dummy"
+mender_tenant_token="dummy"
 
-declare -a sdimgmappings
+declare -a mender_disk_mappings
 
 create_client_files() {
   cat <<- EOF > $mender_dir/mender.service
@@ -80,14 +84,14 @@ create_client_files() {
 	    "RootfsPartA": "/dev/mmcblk0p2",
 	    "RootfsPartB": "/dev/mmcblk0p3",
 	    "ServerCertificate": "/etc/mender/server.crt",
-	    "ServerURL": "$server_url",
-	    "TenantToken": "$tenant_token",
+	    "ServerURL": "$mender_server_url",
+	    "TenantToken": "$mender_tenant_token",
 	    "UpdatePollIntervalSeconds": 5
 	}
 	EOF
 
   cat <<- EOF > $mender_dir/artifact_info
-	artifact_name=${artifact}
+	artifact_name=${artifact_name}
 	EOF
 
   # Version file
@@ -181,7 +185,7 @@ install_files() {
 
   sudo ln -s /data/${dataconfdir} ${primary_dir}/${localstatedir}
 
-  sudo install -m 0755 ${mender} ${primary_dir}/${bindir}/mender
+  sudo install -m 0755 ${mender_client} ${primary_dir}/${bindir}/mender
 
   sudo install -t ${primary_dir}/${identitydir} -m 0755 \
       ${mender_dir}/mender-device-identity
@@ -203,22 +207,22 @@ install_files() {
 
   sudo install -m 0644 ${mender_dir}/version ${primary_dir}/${sysconfdir}/scripts
 
-  if [ -n "${demo_ip}" ]; then
-    echo "$demo_ip docker.mender.io s3.docker.mender.io" | sudo tee -a $primary_dir/etc/hosts
+  if [ -n "${demo_host_ip}" ]; then
+    echo "$demo_host_ip docker.mender.io s3.docker.mender.io" | sudo tee -a $primary_dir/etc/hosts
   fi
 
-  if [ -n "${certificate}" ]; then
-    sudo install -m 0444 ${certificate} ${primary_dir}/${sysconfdir}
+  if [ -n "${server_cert}" ]; then
+    sudo install -m 0444 ${server_cert} ${primary_dir}/${sysconfdir}
   fi
 }
 
 do_install_mender() {
-  if [ -z "${image}" ]; then
-    echo ".sdimg image file not set. Aborting."
+  if [ -z "${mender_disk_image}" ]; then
+    echo "Mender raw disk image not set. Aborting."
     show_help
   fi
 
-  if [ -z "${mender}" ]; then
+  if [ -z "${mender_client}" ]; then
     echo "Mender client binary not set. Aborting."
     show_help
   fi
@@ -228,41 +232,42 @@ do_install_mender() {
     show_help
   fi
 
-  if [ -z "${artifact}" ]; then
+  if [ -z "${artifact_name}" ]; then
     echo "Artifact info not set. Aborting."
     show_help
   fi
 
-  if [ -z "${production_url}" ] && [ -z "${demo_ip}" ] && \
-     [ -z "${hosted_token}" ]; then
+  if [ -z "${server_url}" ] && [ -z "${demo_host_ip}" ] && \
+     [ -z "${tenant_token}" ]; then
     echo "No server type specified. Aborting."
     show_help
   fi
 
-  if [ -n "${production_url}" ] && [ -n "${demo_ip}" ]; then
+  if [ -n "${server_url}" ] && [ -n "${demo_host_ip}" ]; then
     echo "Incompatible server type choice. Aborting."
     show_help
   fi
 
   # TODO: more error checking of server types
-  if [ -n "${hosted_token}" ]; then
-    tenant_token=$(echo ${hosted_token} | tr -d '\n')
-    server_url="https://hosted.mender.io"
+  if [ -n "${tenant_token}" ]; then
+    mender_tenant_token=$(echo ${tenant_token} | tr -d '\n')
+    mender_server_url="https://hosted.mender.io"
   fi
 
-  if [ -n "${production_url}" ]; then
-    server_url=${production_url}
+  if [ -n "${server_url}" ]; then
+    mender_server_url=${server_url}
   fi
 
-  [ ! -f $image ] && { echo "$image - file not found. Aborting."; exit 1; }
+  [ ! -f $mender_disk_image ] && \
+      { echo "$mender_disk_image - file not found. Aborting."; exit 1; }
 
   # Mount rootfs partition A.
-  create_device_maps $image sdimgmappings
+  create_device_maps $mender_disk_image mender_disk_mappings
 
   mkdir -p $output_dir && cd $output_dir
 
-  primary=${sdimgmappings[1]}
-  data=${sdimgmappings[3]}
+  primary=${mender_disk_mappings[1]}
+  data=${mender_disk_mappings[3]}
 
   map_primary=/dev/mapper/"$primary"
   map_data=/dev/mapper/"$data"
@@ -286,7 +291,7 @@ do_install_mender() {
   cd $tool_dir && sync
 
   # Clean stuff.
-  detach_device_maps ${sdimgmappings[@]}
+  detach_device_maps ${mender_disk_mappings[@]}
   rm -rf $output_dir/sdimg
 }
 
@@ -294,36 +299,36 @@ PARAMS=""
 
 while (( "$#" )); do
   case "$1" in
-    -i | --image)
-      image=$2
+    -m | --mender-disk-image)
+      mender_disk_image=$2
       shift 2
       ;;
-    -m | --mender)
-      mender=$2
+    -g | --mender-client)
+      mender_client=$2
       shift 2
       ;;
     -d | --device-type)
       device_type=$2
       shift 2
       ;;
-    -a | --artifact)
-      artifact=$2
+    -a | --artifact-name)
+      artifact_name=$2
       shift 2
       ;;
-    -p | --demo-ip)
-      demo_ip=$2
+    -i | --demo-host-ip)
+      demo_host_ip=$2
       shift 2
       ;;
-    -c | --certificate)
-      certificate=$2
+    -c | --server-cert)
+      server_cert=$2
       shift 2
       ;;
-    -u | --production-url)
-      production_url=$2
+    -u | --server-url)
+      server_url=$2
       shift 2
       ;;
-    -o | --hosted-token)
-      hosted_token=$2
+    -t | --tenant-token)
+      tenant_token=$2
       shift 2
       ;;
     -h | --help)

mender-convert-functions.sh

@@ -9,8 +9,8 @@ heads=255
 # Number of required sectors in a final image.
 sectors=63
 
-declare -a sdimg_partitions=("boot" "primary" "secondary" "data")
-declare -a embedded_partitions=("boot" "rootfs")
+declare -a mender_disk_partitions=("boot" "primary" "secondary" "data")
+declare -a raw_disk_partitions=("boot" "rootfs")
 
 tool_dir="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
 files_dir=${tool_dir}/files
@@ -105,7 +105,7 @@ EOF
 
 # Takes following arguments:
 #
-#  $1 - embedded image path
+#  $1 - raw_disk image path
 #
 # Calculates following values:
 #
@@ -180,7 +180,7 @@ get_image_info() {
 #  $5 - rootfs A partition size (in sectors)
 #  $6 - rootfs B partition start offset (in sectors)
 #  $7 - rootfs B partition size (in sectors)
-get_sdimg_info() {
+get_mender_disk_info() {
   local limage=$1
   local rvar_count=$2
   local rvar_sectorsize=$3
@@ -196,7 +196,7 @@ get_sdimg_info() {
   local lcount=${#lparts[@]}
 
   if [[ $lcount -ne 4 ]]; then
-    echo "Error: invalid source .sdimg file. Aborting."
+    echo "Error: invalid Mender disk image. Aborting."
     return 1
   else
     local lsectorsize=($(echo "${lfdisk}" | grep '^Sector' | cut -d' ' -f4))
@@ -247,7 +247,7 @@ align_partition_size() {
 
 # Takes following arguments:
 #
-#  $1 - embedded image
+#  $1 - raw_disk image
 #
 # Returns:
 #
@@ -256,7 +256,7 @@ align_partition_size() {
 #  $4 - root filesystem partition size (in sectors)
 #  $5 - sector size (in bytes)
 #  $6 - image type
-analyse_embedded_image() {
+analyse_raw_disk_image() {
   local image=$1
   local count=
   local sectorsize=
@@ -276,15 +276,15 @@ analyse_embedded_image() {
           rootfsstart rootfssize bootflag
 
   [[ $? -ne 0 ]] && \
-      { echo "Error: invalid/unsupported embedded image. Aborting."; exit 1; }
+      { echo "Error: invalid/unsupported raw_disk image. Aborting."; exit 1; }
 
   if [[ $count -eq 1 ]]; then
-    echo -e "\nDetected single partition embedded image."
+    echo -e "\nDetected single partition raw_disk image."
     rootfssize=$bootsize
     # Default size of the boot partition: 16MiB.
     bootsize=$(( ($partition_alignment * 2) / $sectorsize ))
   elif [[ $count -eq 2 ]]; then
-    echo -e "\nDetected multipartition ($count) embedded image."
+    echo -e "\nDetected multipartition ($count) raw_disk image."
   fi
 
   # Boot partition storage offset is defined from the top down.
@@ -318,7 +318,7 @@ analyse_embedded_image() {
 #
 #  $6 - aligned data partition size (in sectors)
 #  $7 - final .sdimg file size (in bytes)
-calculate_sdimg_size() {
+calculate_mender_disk_size() {
   local rvar_datasize=$6
   local rvar_sdimgsize=$7
 
@@ -356,13 +356,13 @@ erase_filesystem() {
 #
 #  $1 - raw disk image path
 #  $2 - raw disk image size
-create_sdimg() {
+create_mender_disk() {
   local lfile=$1
   local lsize=$2
   local bs=$(( 1024*1024 ))
   local count=$(( ${lsize} / ${bs} ))
 
-  echo -e "\nWriting $lsize bytes to .sdimg file..."
+  echo -e "\nWriting $lsize bytes to Mender disk image..."
   dd if=/dev/zero of=${lfile} bs=${bs} count=${count}
 }
 
@@ -375,7 +375,7 @@ create_sdimg() {
 #  $5 - root filesystem partiotion size
 #  $6 - data partition size
 #  $7 - sector size
-format_sdimg() {
+format_mender_disk() {
   local lfile=$1
   local lsize=$2
 
@@ -400,7 +400,7 @@ format_sdimg() {
 
   echo $3 ${pboot_offset} $primary_start $secondary_start $data_start $data_offset
 
-  echo -e "\nFormatting .sdimg file..."
+  echo -e "\nFormatting Mender disk image..."
 
   sed -e 's/\s*\([\+0-9a-zA-Z]*\).*/\1/' << EOF | sudo fdisk ${lfile}
 	o # clear the in memory partition table
@@ -447,7 +447,7 @@ EOF
 # Returns:
 #
 #  $2 - number of detected partitions
-verify_sdimg() {
+verify_mender_disk() {
   local lfile=$1
   local rvar_no_of_parts=$2
 
@@ -513,7 +513,7 @@ detach_device_maps() {
 # Takes following arguments:
 #
 #  $1 - partition mappings holder
-make_sdimg_filesystem() {
+make_mender_disk_filesystem() {
   local mappings=($@)
   echo -e "\nCreating filesystem for ${#mappings[@]} partitions..."
 
@@ -525,9 +525,9 @@ make_sdimg_filesystem() {
     echo -e "\nFormatting partition: ${part_no}..."
 
     if [[ part_no -eq 1 ]]; then
-      sudo mkfs.vfat -n ${sdimg_partitions[${part_no} - 1]} $map_dev
+      sudo mkfs.vfat -n ${mender_disk_partitions[${part_no} - 1]} $map_dev
     else
-      sudo mkfs.ext4 -L ${sdimg_partitions[${part_no} - 1]} $map_dev
+      sudo mkfs.ext4 -L ${mender_disk_partitions[${part_no} - 1]} $map_dev
     fi
   done
 }
@@ -535,7 +535,7 @@ make_sdimg_filesystem() {
 # Takes following arguments:
 #
 #  $1 - partition mappings holder
-mount_embedded() {
+mount_raw_disk() {
   local mappings=($@)
 
   if [ ${#mappings[@]} -eq 1 ]; then
@@ -548,7 +548,7 @@ mount_embedded() {
   for mapping in ${mappings[@]}
   do
     local part_no=${mapping#*p*p}
-    local path=$embedded_base_dir/${embedded_partitions[${part_no} - 1]}
+    local path=$embedded_base_dir/${raw_disk_partitions[${part_no} - 1]}
     mkdir -p $path
     sudo mount /dev/mapper/"${mapping}" $path 2>&1 >/dev/null
   done
@@ -557,13 +557,13 @@ mount_embedded() {
 # Takes following arguments:
 #
 #  $1 - partition mappings holder
-mount_sdimg() {
+mount_mender_disk() {
   local mappings=($@)
 
   for mapping in ${mappings[@]}
   do
     local part_no=${mapping#*p*p}
-    local path=$sdimg_base_dir/${sdimg_partitions[${part_no} - 1]}
+    local path=$sdimg_base_dir/${mender_disk_partitions[${part_no} - 1]}
     mkdir -p $path
     sudo mount /dev/mapper/"${mapping}" $path 2>&1 >/dev/null
   done

mender-convert.sh

@@ -32,41 +32,58 @@ Expert commands:
         install-bootloader-to-mender-disk-image - installs bootloader (U-Boot/GRUB)
                                                   related files
 
-Options: [-e|--embedded | -i|--image | -s|--size-data | -d|--device-type |
-          -r|--rootfs_type | -p| --demo-ip | -c| --certificate |
-          -u| --production-url | -o| --hosted-token]
-
-        embedded       - raw disk embedded linux image path, e.g. Debian 9.3, Raspbian, etc.
-        image          - raw disk .sdimg file name where the script writes to
-        size-data      - size of data partition in MiB; default value 128MiB
-        device-type    - target device identification used to build .sdimg name
-        rootfs_type    - selects rootfs_a|rootfs_b as the source filesystem for an artifact
-        demo_ip        - server demo ip used for testing purposes
-        certificate    - server certificate file
-        production-url - production server url
-        hosted-token   - mender hosted token
-
-        Note: root filesystem size used in .sdimg creation can be found as an
-              output from 'raw-disk-image-shrink-rootfs' command or, in case of
-              using unmodified embedded raw disk image, can be checked with any
-              partition manipulation program (e.g. parted, fdisk, etc.).
+Options: [-r|--raw-disk-image | -m|--mender-disk-image | -s|--data-part-size-mb |
+          -d|--device-type | -p|--rootfs-partition-id | -i|--demo-host-ip |
+          -c| --server-cert | -u| --server-url | -t|--tenant-token |
+          -g|--mender-client -b|--bootloader-toolchain | -a|--artifact-name |
+          -k|--keep]
+
+        raw-disk-image       - raw disk embedded Linux (Debian, Raspbian,
+                               Ubuntu, etc.) image path
+        mender-disk-image    - Mender disk image name where the script writes to
+                               should have "sdimg" suffix
+        data-part-size-mb    - data partition size in MB; default value 128MB
+        device-type          - target device identification used to build
+                               Mender image
+        rootfs-partition-id  - selects root filesystem (rootfs_a|rootfs_b) as the
+                               source filesystem for an artifact
+        demo-host-ip         - server demo ip used for testing purposes
+        server-cert          - server certificate file
+        server-url           - production server url
+        tenant-token         - Mender tenant token
+        mender-client        - Mender client binary
+        bootloader-toolchain - GNU Arm Embedded Toolchain
+        artifact-name        - Mender artifact name
+        keep                 - keep intermediate files in output directory
+
+        Note: root filesystem size used in Mender image creation can be found as
+              an output from 'raw-disk-image-shrink-rootfs' command or, in case
+              of using unmodified embedded raw disk image, can be checked with
+              any partition manipulation program (e.g. parted, fdisk, etc.).
 
 Examples:
 
     To create fully functional Mender image from raw disk image in a single step:
 
-        ./mender-convert.sh from-raw-disk-image --embedded <embedded_image_file_path>
-                --image <sdimg_file_name> --device-type raspberrypi3
-                --mender <mender_binary_path> --artifact release-1_1.5.0
-                --demo-ip 192.168.10.2 --toolchain arm-linux-gnueabihf --keep
+        ./mender-convert.sh from-raw-disk-image
+                --raw-disk-image <raw_disk_image_path>
+                --mender-disk-image <mender_image_name>
+                --device-type <beaglebone | raspberrypi3>
+                --mender-client <mender_binary_path>
+                --artifact-name release-1_1.5.0
+                --bootloader-toolchain arm-linux-gnueabihf
+                --demo-host-ip 192.168.10.2
+                --keep
 
         Output: ready to use Mender image with Mender client and bootloader installed
 
     To create Mender artifact file from Mender image:
 
-        ./mender-convert.sh mender-disk-image-to-artifact --image <sdimg_file_path>
-                --device-type beaglebone --artifact release-1_1.5.0
-                --rootfs-type rootfs_a
+        ./mender-convert.sh mender-disk-image-to-artifact
+                --mender-disk-image <mender_image_path>
+                --device-type <beaglebone | raspberrypi3>
+                --artifact-name release-1_1.5.0
+                --rootfs-partition-id rootfs_a
 
         Note: artifact name format is: release-<release_no>_<mender_version>
 
@@ -74,30 +91,38 @@ Examples for expert actions:
 
     To shrink the existing embedded raw disk image:
 
-        ./mender-convert.sh raw-disk-image-shrink-rootfs --embedded <embedded_image_file_path>
+        ./mender-convert.sh raw-disk-image-shrink-rootfs
+                --raw-disk-image <raw_disk_image_path>
 
         Output: Root filesystem size (sectors): 4521984
 
     To convert raw disk image's partition table to Mender layout:
 
-        ./mender-convert.sh raw-disk-image-create-partitions --image <sdimg_file_name>
-                --embedded <embedded_image_file_path>
-                --size-data 128 --device-type beaglebone
+        ./mender-convert.sh raw-disk-image-create-partitions
+                --raw-disk-image <raw_disk_image_path>
+                --mender-disk-image <mender_image_name>
+                --device-type <beaglebone | raspberrypi3>
+                --data-part-size-mb 128
 
 	Output: repartitioned (respectively to Mender layout) raw disk image
 
     To install Mender client related files:
 
-        ./mender-convert.sh install-mender-to-mender-disk-image --image <sdimg_file_path>
-                --device-type beaglebone --artifact release-1_1.5.0
-                --demo-ip 192.168.10.2 --mender <mender_binary_path>
+        ./mender-convert.sh install-mender-to-mender-disk-image
+                --mender-disk-image <mender_image_path>
+                --device-type <beaglebone | raspberrypi3>
+                --artifact-name release-1_1.5.0
+                --demo-host-ip 192.168.10.2
+                --mender-client <mender_binary_path>
 
         Output: Mender image with Mender client related files installed
 
     To install bootloader (U-Boot/GRUB) related files:
 
-        ./mender-convert.sh install-bootloader-to-mender-disk-image --image <sdimg_file_path>
-                --device-type beaglebone --toolchain arm-linux-gnueabihf
+        ./mender-convert.sh install-bootloader-to-mender-disk-image
+                --mender-disk-image <mender_image_path>
+                --device-type <beaglebone | raspberrypi3>
+                --bootloader-toolchain arm-linux-gnueabihf
 
         Output: Mender image with appropriate bootloader (U-Boot/GRUB) installed
 
@@ -119,36 +144,36 @@ pboot_start=
 # (i.e 16777216 bytes, equals to 'partition_alignment' * 2)
 pboot_size=
 # Default 'data' partition size in MiB.
-data_size=128
+data_part_size_mb=128
 # Data partition size in sectors.
 pdata_size=
 # Exemplary values for Beaglebone: 9.3: 4521984 9.4: 4423680
 prootfs_size=
 
-menderimage=
-embeddedimage=
+mender_disk_image=
+raw_disk_image=
 device_type=
 partitions_number=
-artifact=
-rootfs_type=
+artifact_name=
+rootfs_partition_id=
 image_type=
-mender=
+mender_client=
 # Mender production certificate.
-certificate=
+server_cert=
 # Mender production server url.
-production_url=
+server_url=
 # Mender demo server IP address.
-demo_ip=
+demo_host_ip=
 # Mender hosted token.
-hosted_token=
+tenant_token=
 
-declare -a rootfs_types=("rootfs_a" "rootfs_b")
-declare -a sdimgmappings
-declare -a embedmappings
+declare -a rootfs_partition_ids=("rootfs_a" "rootfs_b")
+declare -a mender_disk_mappings
+declare -a raw_disk_mappings
 
 do_raw_disk_image_shrink_rootfs() {
-  if [ -z "${embeddedimage}" ]; then
-    echo "Embedded image not set. Aborting."
+  if [ -z "${raw_disk_image}" ]; then
+    echo "Raw disk image not set. Aborting."
     exit 1
   fi
 
@@ -159,8 +184,8 @@ do_raw_disk_image_shrink_rootfs() {
   local rootfssize=
   local bootflag=
 
-  # Gather information about embedded image.
-  get_image_info $embeddedimage count sector_size bootstart bootsize \
+  # Gather information about raw disk image.
+  get_image_info $raw_disk_image count sector_size bootstart bootsize \
           rootfsstart rootfssize bootflag
 
   # Find first available loopback device.
@@ -168,11 +193,11 @@ do_raw_disk_image_shrink_rootfs() {
 
   # Mount appropriate partition.
   if [[ $count -eq 1 ]]; then
-    sudo losetup $loopdevice $embeddedimage -o $(($bootstart * $sector_size))
+    sudo losetup $loopdevice $raw_disk_image -o $(($bootstart * $sector_size))
   elif [[ $count -eq 2 ]]; then
-    sudo losetup $loopdevice $embeddedimage -o $(($rootfsstart * $sector_size))
+    sudo losetup $loopdevice $raw_disk_image -o $(($rootfsstart * $sector_size))
   else
-    echo "Error: invalid/unsupported embedded image. Aborting."
+    echo "Error: invalid/unsupported embedded raw disk image. Aborting."
     exit 1
   fi
 
@@ -194,7 +219,7 @@ do_raw_disk_image_shrink_rootfs() {
   sudo e2fsck -y -f $loopdevice
 
   sudo losetup -d $loopdevice
-  sudo losetup $loopdevice $embeddedimage
+  sudo losetup $loopdevice $raw_disk_image
 
   if [[ $count -eq 1 ]]; then
     create_single_disk_partition_table $loopdevice $bootstart $new_size_sectors
@@ -208,13 +233,13 @@ do_raw_disk_image_shrink_rootfs() {
 
   sudo losetup -d $loopdevice
   echo "Image new endsector: $endsector"
-  truncate -s $((($endsector+1) * $sector_size)) $embeddedimage
+  truncate -s $((($endsector+1) * $sector_size)) $raw_disk_image
   echo "Root filesystem size (sectors): $new_size_sectors"
 }
 
 do_raw_disk_image_create_partitions() {
-  if [ -z "${embeddedimage}" ]; then
-    echo "Source embedded image not set. Aborting."
+  if [ -z "${raw_disk_image}" ]; then
+    echo "Raw disk image not set. Aborting."
     exit 1
   fi
 
@@ -223,44 +248,44 @@ do_raw_disk_image_create_partitions() {
     exit 1
   fi
 
-  if [[ ! -f ${embeddedimage} ]]; then
-    echo "Source embedded image not found. Aborting."
+  if [[ ! -f ${raw_disk_image} ]]; then
+    echo "Raw disk image not found. Aborting."
     exit 1
   fi
 
   mkdir -p $output_dir && cd $output_dir
 
   # In case of missing .sdimg name use the default format.
-  [ -z $menderimage ] && menderimage=$output_dir/mender_${device_type}.sdimg \
-                      || menderimage=$output_dir/$menderimage
+  [ -z $mender_disk_image ] && mender_disk_image=$output_dir/mender_${device_type}.sdimg \
+                            || mender_disk_image=$output_dir/$mender_disk_image
 
-  analyse_embedded_image ${embeddedimage} pboot_start pboot_size prootfs_size \
+  analyse_raw_disk_image ${raw_disk_image} pboot_start pboot_size prootfs_size \
                          sector_size image_type
 
   [ -z "${prootfs_size}" ] && \
     { echo "root filesystem size not set. Aborting."; exit 1; }
 
-  local menderimage_size=
-  calculate_sdimg_size $pboot_start $pboot_size  \
-                       $prootfs_size $data_size  \
-                       $sector_size pdata_size menderimage_size
+  local mender_disk_image_size=
+  calculate_mender_disk_size $pboot_start $pboot_size  \
+                             $prootfs_size $data_part_size_mb  \
+                             $sector_size pdata_size mender_disk_image_size
 
-  echo -e "Creating Mender *.sdimg file:\
-           \nimage size: ${menderimage_size} bytes\
+  echo -e "Creating Mender disk image:\
+           \nimage size: ${mender_disk_image_size} bytes\
            \nroot filesystem size: ${prootfs_size} sectors\
            \ndata partition size: $pdata_size sectors\n"
 
   create_test_config_file $device_type $partition_alignment $vfat_storage_offset \
-                          $pboot_size $prootfs_size $pdata_size $menderimage_size \
+                          $pboot_size $prootfs_size $pdata_size $mender_disk_image_size \
                           $sector_size
 
-  create_sdimg $menderimage $menderimage_size
-  format_sdimg $menderimage $menderimage_size $pboot_start $pboot_size \
-               $prootfs_size $pdata_size $sector_size
-  verify_sdimg $menderimage partitions_number
+  create_mender_disk $mender_disk_image $mender_disk_image_size
+  format_mender_disk $mender_disk_image $mender_disk_image_size $pboot_start \
+                     $pboot_size $prootfs_size $pdata_size $sector_size
+  verify_mender_disk $mender_disk_image partitions_number
 
-  create_device_maps $menderimage sdimgmappings
-  make_sdimg_filesystem ${sdimgmappings[@]}
+  create_device_maps $mender_disk_image mender_disk_mappings
+  make_mender_disk_filesystem ${mender_disk_mappings[@]}
 
   case "$device_type" in
     "beaglebone")
@@ -275,23 +300,23 @@ do_raw_disk_image_create_partitions() {
 
   echo -e "\nCleaning..."
   # Clean and detach.
-  detach_device_maps ${sdimgmappings[@]}
-  detach_device_maps ${embedmappings[@]}
+  detach_device_maps ${mender_disk_mappings[@]}
+  detach_device_maps ${raw_disk_mappings[@]}
   sync
   rm -rf $embedded_base_dir
   rm -rf $sdimg_base_dir
 
-  [ $rc -eq 0 ] && { echo -e "\n$menderimage image created."; } \
-                || { echo -e "\n$menderimage image composing failure."; }
+  [ $rc -eq 0 ] && { echo -e "\n$mender_disk_image image created."; } \
+                || { echo -e "\n$mender_disk_image image composing failure."; }
 }
 
 do_make_sdimg_beaglebone() {
   local ret=0
 
-  create_device_maps $embeddedimage embedmappings
+  create_device_maps $raw_disk_image raw_disk_mappings
 
-  mount_sdimg ${sdimgmappings[@]}
-  mount_embedded ${embedmappings[@]}
+  mount_mender_disk ${mender_disk_mappings[@]}
+  mount_raw_disk ${raw_disk_mappings[@]}
 
   echo -e "\nSetting boot partition..."
   stage_2_args="$sdimg_boot_dir $embedded_rootfs_dir"
@@ -309,35 +334,35 @@ do_make_sdimg_beaglebone() {
 }
 
 do_make_sdimg_raspberrypi3() {
-  image_boot_part=$(fdisk -l ${embeddedimage} | grep FAT32)
+  image_boot_part=$(fdisk -l ${raw_disk_image} | grep FAT32)
 
   boot_part_start=$(echo ${image_boot_part} | awk '{print $2}')
   boot_part_end=$(echo ${image_boot_part} | awk '{print $3}')
   boot_part_size=$(echo ${image_boot_part} | awk '{print $4}')
 
-  extract_file_from_image ${embeddedimage} ${boot_part_start} \
+  extract_file_from_image ${raw_disk_image} ${boot_part_start} \
                           ${boot_part_size} "boot.vfat"
 
-  image_rootfs_part=$(fdisk -l ${embeddedimage} | grep Linux)
+  image_rootfs_part=$(fdisk -l ${raw_disk_image} | grep Linux)
 
   rootfs_part_start=$(echo ${image_rootfs_part} | awk '{print $2}')
   rootfs_part_end=$(echo ${image_rootfs_part} | awk '{print $3}')
   rootfs_part_size=$(echo ${image_rootfs_part} | awk '{print $4}')
 
-  extract_file_from_image ${embeddedimage} ${rootfs_part_start} \
+  extract_file_from_image ${raw_disk_image} ${rootfs_part_start} \
                           ${rootfs_part_size} "rootfs.img"
 
   echo -e "\nSetting boot partition..."
-  stage_2_args="$output_dir ${sdimgmappings[0]}"
+  stage_2_args="$output_dir ${mender_disk_mappings[0]}"
   ${tool_dir}/rpi3-convert-stage-2.sh ${stage_2_args} || ret=$?
   [[ $ret -ne 0 ]] && { echo "Aborting."; return $ret; }
 
   echo -e "\nSetting root filesystem..."
-  stage_3_args="$output_dir ${sdimgmappings[1]}"
+  stage_3_args="$output_dir ${mender_disk_mappings[1]}"
   ${tool_dir}/rpi3-convert-stage-3.sh ${stage_3_args} || ret=$?
   [[ $ret -ne 0 ]] && { echo "Aborting."; return $ret; }
 
-  mount_sdimg ${sdimgmappings[@]}
+  mount_mender_disk ${mender_disk_mappings[@]}
 
   # Add mountpoints.
   sudo install -d -m 755 ${sdimg_primary_dir}/uboot
@@ -348,28 +373,28 @@ do_make_sdimg_raspberrypi3() {
 
 do_install_mender_to_mender_disk_image() {
   # Mender executables, service and configuration files installer.
-  if [ -z "$menderimage" ] || [ -z "$device_type" ] || [ -z "$mender" ] || \
-     [ -z "$artifact" ]; then
+  if [ -z "$mender_disk_image" ] || [ -z "$device_type" ] || [ -z "$mender_client" ] || \
+     [ -z "$artifact_name" ]; then
     show_help
     exit 1
   fi
   # mender-image-1.5.0
-  stage_4_args="-i $menderimage -d $device_type -m ${mender} -a ${artifact}"
+  stage_4_args="-m $mender_disk_image -d $device_type -g ${mender_client} -a ${artifact_name}"
 
-  if [ -n "$demo_ip" ]; then
-    stage_4_args="${stage_4_args} -p ${demo_ip}"
+  if [ -n "$demo_host_ip" ]; then
+    stage_4_args="${stage_4_args} -i ${demo_host_ip}"
   fi
 
-  if [ -n "$certificate" ]; then
-    stage_4_args="${stage_4_args} -c ${certificate}"
+  if [ -n "$server_cert" ]; then
+    stage_4_args="${stage_4_args} -c ${server_cert}"
   fi
 
-  if [ -n "$production_url" ]; then
-    stage_4_args="${stage_4_args} -u ${production_url}"
+  if [ -n "$server_url" ]; then
+    stage_4_args="${stage_4_args} -u ${server_url}"
   fi
 
-  if [ -n "${hosted_token}" ]; then
-    stage_4_args="${stage_4_args} -o ${hosted_token}"
+  if [ -n "${tenant_token}" ]; then
+    stage_4_args="${stage_4_args} -t ${tenant_token}"
   fi
 
   eval set -- " ${stage_4_args}"
@@ -380,19 +405,19 @@ do_install_mender_to_mender_disk_image() {
   ${tool_dir}/convert-stage-4.sh ${stage_4_args}
 
   # Update test configuration file
-  update_test_config_file $device_type artifact-name $artifact
+  update_test_config_file $device_type artifact-name $artifact_name
 }
 
 do_install_bootloader_to_mender_disk_image() {
-  if [ -z "$menderimage" ] || [ -z "$device_type" ] || \
-     [ -z "$toolchain" ]; then
+  if [ -z "$mender_disk_image" ] || [ -z "$device_type" ] || \
+     [ -z "$bootloader_toolchain" ]; then
     show_help
     exit 1
   fi
 
   case "$device_type" in
     "beaglebone")
-      stage_5_args="-i $menderimage -d $device_type -t ${toolchain} $keep"
+      stage_5_args="-m $mender_disk_image -d $device_type -b ${bootloader_toolchain} $keep"
       eval set -- " ${stage_5_args}"
       export -f create_device_maps
       export -f detach_device_maps
@@ -403,11 +428,11 @@ do_install_bootloader_to_mender_disk_image() {
                                            mount-location "\/boot\/efi"
       ;;
     "raspberrypi3")
-      stage_5_args="-i $menderimage -d $device_type -t ${toolchain} $keep"
+      stage_5_args="-m $mender_disk_image -d $device_type -b ${bootloader_toolchain} $keep"
       eval set -- " ${stage_5_args}"
       export -f create_device_maps
       export -f detach_device_maps
-      export -f mount_sdimg
+      export -f mount_mender_disk
       ${tool_dir}/rpi3-convert-stage-5.sh ${stage_5_args}
 
       # Update test configuration file
@@ -417,8 +442,8 @@ do_install_bootloader_to_mender_disk_image() {
 }
 
 do_mender_disk_image_to_artifact() {
-  if [ -z "${menderimage}" ]; then
-    echo "Raw disk .sdimg image not set. Aborting."
+  if [ -z "${mender_disk_image}" ]; then
+    echo "Mender disk image not set. Aborting."
     exit 1
   fi
 
@@ -427,17 +452,17 @@ do_mender_disk_image_to_artifact() {
     exit 1
   fi
 
-  if [ -z "${artifact}" ]; then
+  if [ -z "${artifact_name}" ]; then
     echo "Artifact name not set. Aborting."
     exit 1
   fi
 
-  if [ -z "${rootfs_type}" ]; then
-    echo "Artifact name not set. rootfs_a will be used by default."
-    rootfs_type="rootfs_a"
+  if [ -z "${rootfs_partition_id}" ]; then
+    echo "Rootfs partition id not set - rootfs_a will be used by default."
+    rootfs_partition_id="rootfs_a"
   fi
 
-  inarray=$(echo ${rootfs_types[@]} | grep -o $rootfs_type | wc -w)
+  inarray=$(echo ${rootfs_partition_ids[@]} | grep -o $rootfs_partition_id | wc -w)
 
   [[ $inarray -eq 0 ]] && \
       { echo "Error: invalid rootfs type provided. Aborting."; exit 1; }
@@ -452,19 +477,19 @@ do_mender_disk_image_to_artifact() {
   local sdimg_device_type=
   local abort=0
 
-  get_sdimg_info $menderimage count sector_size rootfs_a_start rootfs_a_size \
-          rootfs_b_start rootfs_b_size
+  get_mender_disk_info $mender_disk_image count sector_size rootfs_a_start \
+                       rootfs_a_size rootfs_b_start rootfs_b_size
   ret=$?
   [[ $ret -ne 0 ]] && \
-      { echo "Error: cannot validate input .sdimg image. Aborting."; exit 1; }
+      { echo "Error: cannot validate Mender disk image. Aborting."; exit 1; }
 
-  create_device_maps $menderimage sdimgmappings
-  mount_sdimg ${sdimgmappings[@]}
+  create_device_maps $mender_disk_image mender_disk_mappings
+  mount_mender_disk ${mender_disk_mappings[@]}
 
-  if [[ $rootfs_type == "rootfs_a" ]]; then
+  if [[ $rootfs_partition_id == "rootfs_a" ]]; then
     prootfs_size=$rootfs_a_size
     rootfs_path=$sdimg_primary_dir
-  elif [[ $rootfs_type == "rootfs_b" ]]; then
+  elif [[ $rootfs_partition_id == "rootfs_b" ]]; then
     prootfs_size=$rootfs_b_size
     rootfs_path=$sdimg_secondary_dir
   fi
@@ -473,7 +498,7 @@ do_mender_disk_image_to_artifact() {
   sdimg_device_type=$( cat $sdimg_data_dir/mender/device_type | sed 's/[^=].*=//' )
 
   # Set 'artifact name' as passed in the command line.
-  sudo sed -i '/^artifact/s/=.*$/='${artifact}'/' "$rootfs_path/etc/mender/artifact_info"
+  sudo sed -i '/^artifact/s/=.*$/='${artifact_name}'/' "$rootfs_path/etc/mender/artifact_info"
 
   if [ "$sdimg_device_type" != "$device_type" ]; then
     echo "Error: .mender and .sdimg device type not matching. Aborting."
@@ -495,14 +520,14 @@ do_mender_disk_image_to_artifact() {
 
     fsck.ext4 -fp $rootfs_file
 
-    mender_artifact=${output_dir}/${device_type}_${artifact}.mender
+    mender_artifact=${output_dir}/${device_type}_${artifact_name}.mender
     echo "Writing Mender artifact to: ${mender_artifact}"
 
     #Create Mender artifact
     mender-artifact write rootfs-image \
       --update ${rootfs_file} \
       --output-path ${mender_artifact} \
-      --artifact-name ${artifact} \
+      --artifact-name ${artifact_name} \
       --device-type ${device_type}
 
     ret=$?
@@ -514,7 +539,7 @@ do_mender_disk_image_to_artifact() {
   fi
 
   # Clean and detach.
-  detach_device_maps ${sdimgmappings[@]}
+  detach_device_maps ${mender_disk_mappings[@]}
 
   rm -rf $sdimg_base_dir
 }
@@ -535,52 +560,52 @@ source ${tool_dir}/mender-convert-functions.sh
 
 while (( "$#" )); do
   case "$1" in
-    -r | --rootfs-type)
-      rootfs_type=$2
+    -p | --rootfs-partition-id)
+      rootfs_partition_id=$2
       shift 2
       ;;
-    -i | --image)
-      menderimage=$2
+    -m | --mender-disk-image)
+      mender_disk_image=$2
       shift 2
       ;;
-    -e | --embedded)
-      embeddedimage=$(get_path $2)
+    -r | --raw-disk-image)
+      raw_disk_image=$(get_path $2)
       shift 2
       ;;
-    -s | --size-data)
-      data_size=$2
+    -s | --data-part-size-mb)
+      data_part_size_mb=$2
       shift 2
       ;;
     -d | --device-type)
       device_type=$2
       shift 2
       ;;
-    -a | --artifact)
-      artifact=$2
+    -a | --artifact-name)
+      artifact_name=$2
       shift 2
       ;;
-    -m | --mender)
-      mender=$(get_path $2)
+    -g | --mender-client)
+      mender_client=$(get_path $2)
       shift 2
       ;;
-    -t | --toolchain)
-      toolchain=$2
+    -b | --bootloader-toolchain)
+      bootloader_toolchain=$2
       shift 2
       ;;
-    -p | --demo-ip)
-      demo_ip=$2
+    -i | --demo-host-ip)
+      demo_host_ip=$2
       shift 2
       ;;
-    -c | --certificate)
-      certificate=$2
+    -c | --server-cert)
+      server_cert=$2
       shift 2
       ;;
-    -u | --production-url)
-      production_url=$2
+    -u | --server-url)
+      server_url=$2
       shift 2
       ;;
-    -o | --hosted-token)
-      hosted_token=$2
+    -t | --tenant-token)
+      tenant_token=$2
       shift 2
       ;;
     -k | --keep)
@@ -606,8 +631,8 @@ while (( "$#" )); do
   esac
 done
 
-[ -z "${data_size}" ] && \
-    { echo "Default 'data' partition size set to 128MiB"; data_size=128; }
+[ -z "${data_part_size_mb}" ] && \
+    { echo "Default 'data' partition size set to 128MB"; data_part_size_mb=128; }
 
 eval set -- "$PARAMS"
 

rpi3-convert-stage-5.sh

@@ -23,8 +23,8 @@ sdimg_base_dir=$output_dir/sdimg
 GCC_VERSION="6.3.1"
 
 echo "Running: $(basename $0)"
-declare -a sdimgmappings
-declare -a sdimg_partitions=("boot" "primary" "secondary" "data")
+declare -a mender_disk_mappings
+declare -a mender_disk_partitions=("boot" "primary" "secondary" "data")
 
 version() {
   echo "$@" | awk -F. '{ printf("%d%03d%03d\n", $1,$2,$3); }'
@@ -55,7 +55,7 @@ build_uboot_files() {
   cd $uboot_dir
 
   make --quiet distclean
-  make rpi_3_32b_defconfig && make
+  make --quiet rpi_3_32b_defconfig && make --quiet
   make envtools
 
   cat<<-'EOF' >boot.cmd
@@ -142,43 +142,44 @@ install_files() {
 do_install_bootloader() {
   echo "Setting bootloader..."
 
-  if [ -z "${image}" ]; then
-    echo ".sdimg image file not set. Aborting."
+  if [ -z "${mender_disk_image}" ]; then
+    echo "Mender raw disk image file not set. Aborting."
     exit 1
   fi
 
-  if [ -z "${toolchain}" ]; then
-    echo "ARM toolchain not set. Aborting."
+  if [ -z "${bootloader_toolchain}" ]; then
+    echo "ARM GCC toolchain not set. Aborting."
     exit 1
   fi
 
-  if [[ $(which ${toolchain}-gcc) = 1 ]]; then
+  if [[ $(which ${bootloader_toolchain}-gcc) = 1 ]]; then
     echo "Error: ARM GCC not found in PATH. Aborting."
     exit 1
   fi
 
-  local gcc_version=$(${toolchain}-gcc -dumpversion)
+  local gcc_version=$(${bootloader_toolchain}-gcc -dumpversion)
 
   if [ $(version $gcc_version) -ne $(version $GCC_VERSION) ]; then
     echo "Error: Invalid ARM GCC version ($gcc_version). Expected $GCC_VERSION. Aborting."
     exit 1
   fi
 
-  [ ! -f $image ] && { echo "$image - file not found. Aborting."; exit 1; }
+  [ ! -f $mender_disk_image ] && \
+      { echo "$mender_disk_image - file not found. Aborting."; exit 1; }
 
   # Map & mount Mender compliant image.
-  create_device_maps $image sdimgmappings
+  create_device_maps $mender_disk_image mender_disk_mappings
 
   mkdir -p $output_dir && cd $output_dir
 
   # Build patched U-Boot files.
-  build_uboot_files $toolchain
+  build_uboot_files $bootloader_toolchain
 
-  mount_sdimg ${sdimgmappings[@]}
+  mount_mender_disk ${mender_disk_mappings[@]}
 
   install_files ${output_dir}/sdimg/boot ${output_dir}/sdimg/primary
 
-  detach_device_maps ${sdimgmappings[@]}
+  detach_device_maps ${mender_disk_mappings[@]}
 
   echo -e "\nStage done."
 }
@@ -188,12 +189,12 @@ PARAMS=""
 
 while (( "$#" )); do
   case "$1" in
-    -i | --image)
-      image=$2
+    -m | --mender-disk-image)
+      mender_disk_image=$2
       shift 2
       ;;
-    -t | --toolchain)
-      toolchain=$2
+    -b | --bootloader-toolchain)
+      bootloader_toolchain=$2
       shift 2
       ;;
     -d | --device-type)