lukechilds
/
mender-convert
mirror of https://github.com/lukechilds/mender-convert.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Rename options names to be more descriptive 

Issues: MEN-2162

Changelog: None

Signed-off-by: Adam Podogrocki <a.podogrocki@gmail.com>
1.0.x
Adam Podogrocki 6 years ago
committed by Adam Podogrocki
parent
ac6b5f8090
commit
aca592e923
5 changed files with 319 additions and 284 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 64
      bbb-convert-stage-5.sh
  2. 131
      convert-stage-4.sh
  3. 46
      mender-convert-functions.sh
  4. 325
      mender-convert.sh
  5. 37
      rpi3-convert-stage-5.sh

64
bbb-convert-stage-5.sh
View File

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

131
convert-stage-4.sh
View File

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

46
mender-convert-functions.sh
View File

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

325
mender-convert.sh
View File

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

37
rpi3-convert-stage-5.sh
View File

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

Write Preview
Loading…
Cancel
Save