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
Split 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() {
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
--device-type - target device type identification
--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)

131
convert-stage-4.sh
View File

@ -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]
--image - .sdimg generated with mender-convert tool
--mender - mender client binary file
--artifact - 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
Options: [-m|--mender-disk-image | -g|--mender-client | -a|--artifact-name |
-d|--device-type | -p|--demo-host-ip | -u| --server-url |
-t| --tenant-token]
--mender-disk-image - Mender raw disk image
--mender-client - Mender client binary file
--artifact-name - artifact info
--device-type - target device type identification
--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)

46
mender-convert-functions.sh
View File

@ -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

325
mender-convert.sh
View File

@ -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 \
sector_size image_type
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"

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

@ -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)

Write Preview
Loading…
Cancel
Save