diff --git a/rpi3-convert-stage-3.sh b/convert-stage-3.sh
similarity index 53%
rename from rpi3-convert-stage-3.sh
rename to convert-stage-3.sh
index 763be39..e657395 100755
--- a/rpi3-convert-stage-3.sh
+++ b/convert-stage-3.sh
@@ -8,9 +8,11 @@ build_log=$output_dir/build.log
     { log "Error: extracted rootfs partition not found. Aborting."; exit 1; }
 
 sudo dd if=${output_dir}/rootfs.img of=/dev/mapper/${rootfs_mapping} bs=8M >> "$build_log" 2>&1
-
-# dd sets the original label, make sure label follows Mender naming convention.
-sudo e2label /dev/mapper/${rootfs_mapping} "primary"
+sync
+# Check Linux ext4 file system just in case.
+sudo fsck.ext4 -fp /dev/mapper/${rootfs_mapping} >> "$build_log" 2>&1
+# Make sure the rootfs partition's label follows Mender naming convention.
+sudo tune2fs -L "primary" /dev/mapper/${rootfs_mapping} >> "$build_log" 2>&1
 
 log "\tDone."
 
diff --git a/convert-stage-4.sh b/convert-stage-4.sh
index 1d7e026..eaa186d 100755
--- a/convert-stage-4.sh
+++ b/convert-stage-4.sh
@@ -59,6 +59,14 @@ mender_tenant_token="dummy"
 declare -a mender_disk_mappings
 
 create_client_files() {
+  local rootfsparta="/dev/mmcblk0p2"
+  local rootfspartb="/dev/mmcblk0p3"
+
+  if [ "$device_type" == "qemux86_64" ]; then
+    rootfsparta="/dev/hda2"
+    rootfspartb="/dev/hda3"
+  fi
+
   cat <<- EOF > $mender_dir/mender.service
 	[Unit]
 	Description=Mender OTA update service
@@ -81,8 +89,8 @@ create_client_files() {
 	{
 	    "InventoryPollIntervalSeconds": 5,
 	    "RetryPollIntervalSeconds": 30,
-	    "RootfsPartA": "/dev/mmcblk0p2",
-	    "RootfsPartB": "/dev/mmcblk0p3",
+	    "RootfsPartA": "$rootfsparta",
+	    "RootfsPartB": "$rootfspartb",
 	    "ServerCertificate": "/etc/mender/server.crt",
 	    "ServerURL": "$mender_server_url",
 	    "TenantToken": "$mender_tenant_token",
@@ -102,7 +110,7 @@ create_client_files() {
 	EOF
 
   case "$device_type" in
-    "beaglebone")
+    "beaglebone" | "qemux86_64")
       cat <<- EOF > $mender_dir/fw_env.config
 	/dev/mmcblk0 0x800000 0x20000
 	/dev/mmcblk0 0x1000000 0x20000
@@ -179,6 +187,13 @@ install_files() {
           { log "\t'/uboot' mountpoint missing. Adding"; \
             sudo install -d -m 755 ${primary_dir}/uboot; }
       ;;
+    "qemux86_64")
+      [ ! -d "$primary_dir/boot/efi" ] && \
+          { log "\t'/boot/efi' mountpoint missing. Adding"; \
+            sudo install -d -m 755 ${primary_dir}/boot/efi; }
+      sudo install -d ${primary_dir}/lib64
+      sudo ln -sf /lib/ld-linux-x86-64.so.2 ${primary_dir}/lib64/ld-linux-x86-64.so.2
+      ;;
   esac
 
   sudo install -d ${primary_dir}/${identitydir}
@@ -273,6 +288,10 @@ do_install_mender() {
   primary=${mender_disk_mappings[1]}
   data=${mender_disk_mappings[3]}
 
+  if [ "$device_type" == "qemux86_64" ]; then
+    data=${mender_disk_mappings[4]}
+  fi
+
   map_primary=/dev/mapper/"$primary"
   map_data=/dev/mapper/"$data"
   path_primary=$output_dir/sdimg/primary
diff --git a/bbb-convert-stage-5.sh b/convert-stage-5.sh
similarity index 77%
rename from bbb-convert-stage-5.sh
rename to convert-stage-5.sh
index 13767d6..16d5ceb 100755
--- a/bbb-convert-stage-5.sh
+++ b/convert-stage-5.sh
@@ -90,6 +90,10 @@ build_env_lock_boot_files() {
 
   sed -i '/^kernel_imagetype/s/=.*$/='${kernel_imagetype}'/' mender_grubenv_defines
   sed -i '/^kernel_devicetree/s/=.*$/='${kernel_devicetree//\//\\/}'/' mender_grubenv_defines
+  if [ "$device_type" == "qemux86_64" ]; then
+    local root_base=/dev/hda
+    sed -i '/^mender_kernel_root_base/s/=.*$/='${root_base//\//\\/}'/' mender_grubenv_defines
+  fi
 
   make --quiet >> "$build_log" 2>&1
   rc=$?
@@ -142,22 +146,32 @@ build_grub_efi() {
   make --quiet -j$cores >> "$build_log" 2>&1
   make --quiet install >> "$build_log" 2>&1
 
-  # Clean workspace.
-  make --quiet clean >> "$build_log" 2>&1
-  make --quiet distclean >> "$build_log" 2>&1
-
-   # Now build ARM modules.
-  ./configure --quiet  --host=$bootloader_toolchain --with-platform=efi \
-      --prefix=$grub_arm_dir CFLAGS="-Os -march=armv7-a" \
-      CCASFLAGS="-march=armv7-a" --disable-werror >> "$build_log" 2>&1
-  make --quiet -j$cores >> "$build_log" 2>&1
-  make --quiet install >> "$build_log" 2>&1
+  local format=${host}-efi
+  grub_name=bootx64.efi
+  local modules_path=$grub_host_dir/lib/grub/$format/
+
+  if [ "$device_type" == "beaglebone" ]; then
+    # Clean workspace.
+    make --quiet clean >> "$build_log" 2>&1
+    make --quiet distclean >> "$build_log" 2>&1
+
+    # Now build ARM modules.
+    ./configure --quiet  --host=$bootloader_toolchain --with-platform=efi \
+        --prefix=$grub_arm_dir CFLAGS="-Os -march=armv7-a" \
+        CCASFLAGS="-march=armv7-a" --disable-werror >> "$build_log" 2>&1
+    make --quiet -j$cores >> "$build_log" 2>&1
+    make --quiet install >> "$build_log" 2>&1
+
+   format=arm-efi
+   grub_name=grub-arm.efi
+   modules_path=$grub_arm_dir/lib/grub/$format/
+  fi
 
   # Build GRUB EFI image.
-  ${grub_host_dir}/bin/grub-mkimage  -v -p /$efi_boot -o grub.efi --format=arm-efi \
-      -d $grub_arm_dir/lib/grub/arm-efi/  boot linux ext2 fat serial part_msdos \
-      part_gpt  normal efi_gop iso9660 configfile search loadenv test cat echo \
-      gcry_sha256 halt hashsum loadenv reboot >> "$build_log" 2>&1
+  ${grub_host_dir}/bin/grub-mkimage  -v -p /$efi_boot -o $grub_name --format=$format \
+      -d $modules_path  boot linux ext2 fat serial part_msdos part_gpt normal	\
+      efi_gop iso9660 configfile search loadenv test cat echo gcry_sha256 halt	\
+      hashsum loadenv reboot >> "$build_log" 2>&1
 
   rc=$?
   [[ $rc -ne 0 ]] && { log "\tBuilding grub.efi failed. Aborting."; } \
@@ -178,7 +192,7 @@ set_uenv() {
   # Fill uEnv.txt file.
   cat <<- 'EOF' | sudo tee $boot_dir/uEnv.txt 2>&1 >/dev/null
 	bootdir=
-	grubfile=EFI/BOOT/grub.efi
+	grubfile=EFI/BOOT/grub-arm.efi
 	grubaddr=0x80007fc0
 	loadgrub=fatload mmc 0:1 ${grubaddr} ${grubfile}
 	grubstart=bootefi ${grubaddr}
@@ -199,6 +213,7 @@ install_files() {
 
   local grub_build_dir=$grub_dir/build
   local grub_arm_dir=$grub_build_dir/arm
+  local grub_host_dir=$grub_build_dir/$(uname -m)
 
   local grubenv_build_dir=$grubenv_dir/build
   local grubenv_efi_boot_dir=$grubenv_build_dir/boot/efi/EFI/BOOT/
@@ -215,8 +230,13 @@ install_files() {
   cd $grubenv_efi_boot_dir && find . -type f -exec sudo install -Dm 644 "{}" "$efi_boot_dir/{}" \;
   cd ${output_dir}
 
-  sudo install -m 0644 ${grub_dir}/grub.efi $efi_boot_dir
-  sudo install -m 0755 ${grub_arm_dir}/bin/grub-editenv $rootfs_dir/usr/bin
+  if [ "$device_type" == "qemux86_64" ]; then
+    sudo install -m 0755 ${grub_host_dir}/bin/grub-editenv $rootfs_dir/usr/bin
+  else
+    sudo install -m 0755 ${grub_arm_dir}/bin/grub-editenv $rootfs_dir/usr/bin
+  fi
+
+  sudo install -m 0644 ${grub_dir}/${grub_name} $efi_boot_dir
 
   sudo install -m 0755 $grubenv_build_dir/usr/bin/fw_printenv $rootfs_dir/sbin/fw_printenv
   sudo install -m 0755 $grubenv_build_dir/usr/bin/fw_setenv $rootfs_dir/sbin/fw_setenv
@@ -225,16 +245,21 @@ install_files() {
   sudo ln -fs /sbin/fw_printenv $rootfs_dir/usr/bin/fw_printenv
   sudo ln -fs /sbin/fw_setenv $rootfs_dir/usr/bin/fw_setenv
 
-  #Replace U-Boot default images for Debian 9.5
-  if grep -q '9.5' $rootfs_dir/etc/debian_version ; then
-     sudo cp ${tool_dir}/files/uboot_debian_9.4/MLO ${boot_dir}/MLO
-     sudo cp ${tool_dir}/files/uboot_debian_9.4/u-boot.img ${boot_dir}/u-boot.img
-  fi
-
   #Create links for grub
-  sudo ln -sf /boot/dtbs/$linux_version/am335x-boneblack.dtb $rootfs_dir/boot/dtb
-  sudo ln -sf /boot/vmlinuz-$linux_version  $rootfs_dir/boot/kernel
-  set_uenv $boot_dir
+  if [ "$device_type" == "qemux86_64" ]; then
+    # Copy kernel image to fit the grubenv defines.
+    sudo cp $boot_dir/bzImage $rootfs_dir/boot/kernel
+  elif [ "$device_type" == "beaglebone" ]; then
+    #Replace U-Boot default images for Debian 9.5
+    if [ `grep -s '9.5' $rootfs_dir/etc/debian_version | wc -l` -eq 1 ]; then
+       sudo cp ${tool_dir}/files/uboot_debian_9.4/MLO ${boot_dir}/MLO
+       sudo cp ${tool_dir}/files/uboot_debian_9.4/u-boot.img ${boot_dir}/u-boot.img
+    fi
+    # Make links to kernel and device tree files.
+    sudo ln -sf /boot/dtbs/$linux_version/am335x-boneblack.dtb $rootfs_dir/boot/dtb
+    sudo ln -sf /boot/vmlinuz-$linux_version  $rootfs_dir/boot/kernel
+    set_uenv $boot_dir
+  fi
 }
 
 do_install_bootloader() {
@@ -283,7 +308,11 @@ do_install_bootloader() {
 
   build_env_lock_boot_files
   rc=$?
-  [[ $rc -eq 0 ]] && { build_grub_efi ${kernel_version}; }
+  if [ "$device_type" == "qemux86_64" ]; then
+    [[ $rc -eq 0 ]] && { build_grub_efi ${EFI_STUB_VER}; }
+  else
+    [[ $rc -eq 0 ]] && { build_grub_efi ${kernel_version}; }
+  fi
   rc=$?
   [[ $rc -eq 0 ]] && { install_files ${path_boot} ${path_primary} ${kernel_version}; }
   rc=$?
diff --git a/mender-convert b/mender-convert
index 723d60b..eeacaf7 100755
--- a/mender-convert
+++ b/mender-convert
@@ -148,17 +148,8 @@ tool_dir="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
 
 # Default sector size
 sector_size=
-# Boot partition start in sectors (512 bytes per sector).
-pboot_start=
-# Default 'boot' partition size in sectors: 16MB
-# (i.e 16777216 bytes, equals to 'partition_alignment' * 2)
-pboot_size=
 # Default 'data' partition size in MiB.
 data_part_size_mb=128
-# Data partition size in sectors.
-pdata_size=
-# Exemplary values for Beaglebone: 9.3: 4521984 9.4: 4423680
-prootfs_size=
 
 mender_disk_image=
 raw_disk_image=
@@ -185,7 +176,7 @@ declare -a rootfs_partition_ids=("primary" "secondary")
 declare -a mender_disk_mappings
 declare -a raw_disk_mappings
 #Supported devices
-declare -a supported_devices=("beaglebone" "raspberrypi3")
+declare -a supported_devices=("beaglebone" "raspberrypi3" "qemux86_64")
 
 do_raw_disk_image_shrink_rootfs() {
   log "$step/$total Shrinking raw disk image root filesystem..."
@@ -195,29 +186,21 @@ do_raw_disk_image_shrink_rootfs() {
     return 1
   fi
 
-  local count=
-  local bootstart=
-  local bootsize=
-  local rootfsstart=
-  local rootfssize=
-  local bootflag=
-
   # For root filesystem partition set 8MB alignment for shrinking purpose.
   partition_alignment=$PART_ALIGN_8MB
 
   # Gather information about raw disk image.
-  get_image_info $raw_disk_image count sector_size bootstart bootsize \
-          rootfsstart rootfssize bootflag
+  get_raw_disk_sizes ${raw_disk_image} raw_disk_counts sector_size raw_disk_sizes
 
   # Find first available loopback device.
   loopdevice=($(losetup -f))
   [ $? -ne 0 ] && { log "Error: inaccesible loopback device"; return 1; }
 
   # Mount appropriate partition.
-  if [[ $count -eq 1 ]]; then
-    sudo losetup $loopdevice $raw_disk_image -o $(($bootstart * $sector_size))
-  elif [[ $count -eq 2 ]]; then
-    sudo losetup $loopdevice $raw_disk_image -o $(($rootfsstart * $sector_size))
+  if [[ $raw_disk_counts -eq 1 ]]; then
+    sudo losetup $loopdevice $raw_disk_image -o $((${raw_disk_sizes[pboot_start]} * $sector_size))
+  elif [[ $raw_disk_counts -eq 2 ]]; then
+    sudo losetup $loopdevice $raw_disk_image -o $((${raw_disk_sizes[prootfs_start]} * $sector_size))
   else
     log "Error: invalid/unsupported embedded raw disk image. Aborting."
     return 1
@@ -241,14 +224,16 @@ do_raw_disk_image_shrink_rootfs() {
   sudo losetup -d $loopdevice
   sudo losetup $loopdevice $raw_disk_image
 
-  if [[ $count -eq 1 ]]; then
-    create_single_disk_partition_table $loopdevice $bootstart $new_size_sectors
-  elif [[ $count -eq 2 ]]; then
-    create_double_disk_partition_table $loopdevice $rootfsstart $new_size_sectors
+  if [[ $raw_disk_counts -eq 1 ]]; then
+    create_single_disk_partition_table $loopdevice \
+        ${raw_disk_sizes[pboot_start]} $new_size_sectors
+  elif [[ $raw_disk_counts -eq 2 ]]; then
+    create_double_disk_partition_table $loopdevice \
+        ${raw_disk_sizes[prootfs_start]} $new_size_sectors
   fi
 
   sudo partprobe
-  endsector=($(sudo parted $loopdevice -ms unit s print | grep "^$count" | cut -f3 -d: | sed 's/[^0-9]*//g'))
+  endsector=($(sudo parted $loopdevice -ms unit s print | grep "^$raw_disk_counts" | cut -f3 -d: | sed 's/[^0-9]*//g'))
 
   sudo losetup -d $loopdevice
   log "\tRaw disk image new endsector: $endsector"
@@ -296,35 +281,44 @@ do_raw_disk_image_create_partitions() {
     mender_disk_image=$output_dir/mender-${device_type}-${artifact_name}.sdimg
   fi
 
-  set_boot_part_alignment $device_type partition_alignment vfat_storage_offset
+  set_mender_disk_alignment $device_type partition_alignment vfat_storage_offset
 
-  analyse_raw_disk_image ${raw_disk_image} ${partition_alignment} ${vfat_storage_offset} \
-                         pboot_start pboot_size prootfs_size sector_size raw_disk_counts
+  get_raw_disk_sizes ${raw_disk_image} raw_disk_counts sector_size raw_disk_sizes
+  rc=$?
+  [ $rc -eq 0 ] || { return 1; }
 
-  [ -z "${prootfs_size}" ] && \
-    { log "root filesystem size not set. Aborting."; return 1; }
+  set_mender_disk_sizes ${raw_disk_counts} ${sector_size} \
+                        ${partition_alignment} ${vfat_storage_offset} \
+                        ${data_part_size_mb} raw_disk_sizes mender_disk_sizes
 
   log "\tDetected raw disk image with $raw_disk_counts partition(s)."
 
   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
+  calculate_mender_disk_size $sector_size ${partition_alignment} \
+                             mender_disk_sizes mender_disk_image_size
 
   log "\tCreating Mender disk image:\
        \n\t\timage size: ${mender_disk_image_size} bytes\
-       \n\t\tboot partition size: $((${pboot_size} * $sector_size)) bytes\
-       \n\t\troot filesystem size: $((${prootfs_size} * $sector_size)) bytes\
-       \n\t\tdata partition size: $(($pdata_size * $sector_size)) bytes"
+       \n\t\tboot partition size: $((${mender_disk_sizes[pboot_size]} * $sector_size)) bytes\
+       \n\t\troot filesystem size: $((${mender_disk_sizes[prootfs_size]} * $sector_size)) bytes\
+       \n\t\tdata partition size: $((${mender_disk_sizes[pdata_size]} * $sector_size)) bytes"
+
+  if [ -v mender_disk_sizes[pswap_size] ]; then
+    log "\t\tswap partition size: $((${mender_disk_sizes[pswap_size]} * $sector_size)) bytes"
+  fi
 
-  create_test_config_file $device_type $partition_alignment $pboot_start \
-                          $pboot_size $prootfs_size $pdata_size $mender_disk_image_size \
-                          $sector_size
+  create_test_config_file $device_type $partition_alignment $mender_disk_image_size \
+                          $sector_size mender_disk_sizes
 
   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 mender_disk_counts
+  format_mender_disk $mender_disk_image $mender_disk_image_size $sector_size \
+                     $partition_alignment mender_disk_sizes mender_disk_counts
+  rc=$?
+  [ $rc -eq 0 ] || { return 1; }
+
+  verify_mender_disk $mender_disk_image $mender_disk_counts
+  rc=$?
+  [ $rc -eq 0 ] || { return 1; }
 
   create_device_maps $mender_disk_image mender_disk_mappings
 
@@ -339,6 +333,9 @@ do_raw_disk_image_create_partitions() {
     "raspberrypi3")
       do_make_sdimg_raspberrypi3
       ;;
+    "qemux86_64")
+      do_make_sdimg_qemux86_64
+      ;;
   esac
 
   rc=$?
@@ -387,11 +384,11 @@ do_make_sdimg_beaglebone() {
 do_make_sdimg_raspberrypi3() {
   log "$step/$total Setting boot partition..."
   ((step++))
-  local image_boot_part=$(fdisk -l ${raw_disk_image} | grep FAT32)
+  local raw_boot_part=$(fdisk -l ${raw_disk_image} | grep FAT32)
 
-  local boot_part_start=$(echo ${image_boot_part} | awk '{print $2}')
-  local boot_part_end=$(echo ${image_boot_part} | awk '{print $3}')
-  local boot_part_size=$(echo ${image_boot_part} | awk '{print $4}')
+  local boot_part_start=$(echo ${raw_boot_part} | awk '{print $2}')
+  local boot_part_end=$(echo ${raw_boot_part} | awk '{print $3}')
+  local boot_part_size=$(echo ${raw_boot_part} | awk '{print $4}')
 
   log "\tExtracting boot partition from raw disk image."
   extract_file_from_image ${raw_disk_image} ${boot_part_start} \
@@ -403,18 +400,18 @@ do_make_sdimg_raspberrypi3() {
 
   log "$step/$total Setting root filesystem partition..."
   ((step++))
-  local image_rootfs_part=$(fdisk -l ${raw_disk_image} | grep Linux)
+  local raw_rootfs_part=$(fdisk -l ${raw_disk_image} | grep Linux)
 
-  local rootfs_part_start=$(echo ${image_rootfs_part} | awk '{print $2}')
-  local rootfs_part_end=$(echo ${image_rootfs_part} | awk '{print $3}')
-  local rootfs_part_size=$(echo ${image_rootfs_part} | awk '{print $4}')
+  local rootfs_part_start=$(echo ${raw_rootfs_part} | awk '{print $2}')
+  local rootfs_part_end=$(echo ${raw_rootfs_part} | awk '{print $3}')
+  local rootfs_part_size=$(echo ${raw_rootfs_part} | awk '{print $4}')
 
   log "\tExtracting root filesystem partition from raw disk image."
   extract_file_from_image ${raw_disk_image} ${rootfs_part_start} \
                           ${rootfs_part_size} "rootfs.img"
 
   stage_3_args="$output_dir ${mender_disk_mappings[1]}"
-  ${tool_dir}/rpi3-convert-stage-3.sh ${stage_3_args} || ret=$?
+  ${tool_dir}/convert-stage-3.sh ${stage_3_args} || ret=$?
   [[ $ret -ne 0 ]] && { return $ret; }
 
   mount_mender_disk ${mender_disk_mappings[@]}
@@ -434,6 +431,56 @@ do_make_sdimg_raspberrypi3() {
   return 0
 }
 
+do_make_sdimg_qemux86_64() {
+  log "$step/$total Setting boot partition..."
+  ((step++))
+
+  local raw_boot_part=$(fdisk -l ${raw_disk_image} | grep 'Microsoft' | sed s/*//)
+
+  local boot_part_start=$(echo ${raw_boot_part} | awk '{print $2}')
+  local boot_part_end=$(echo ${raw_boot_part} | awk '{print $3}')
+  local boot_part_size=$(echo ${raw_boot_part} | awk '{print $4}')
+
+  log "\tExtracting boot partition from raw disk image."
+  extract_file_from_image ${raw_disk_image} ${boot_part_start} \
+                          ${boot_part_size} "boot.vfat"
+
+  stage_2_args="$output_dir ${mender_disk_mappings[0]}"
+  ${tool_dir}/qemux86_64-convert-stage-2.sh ${stage_2_args} || ret=$?
+  [[ $ret -ne 0 ]] && { return $ret; }
+
+  log "$step/$total Setting root filesystem partition..."
+  ((step++))
+  local raw_rootfs_part=$(fdisk -l ${raw_disk_image} | grep 'Linux filesystem')
+
+  local rootfs_part_start=$(echo ${raw_rootfs_part} | awk '{print $2}')
+  local rootfs_part_end=$(echo ${raw_rootfs_part} | awk '{print $3}')
+  local rootfs_part_size=$(echo ${raw_rootfs_part} | awk '{print $4}')
+
+  log "\tExtracting root filesystem partition from raw disk image."
+  extract_file_from_image ${raw_disk_image} ${rootfs_part_start} \
+                          ${rootfs_part_size} "rootfs.img"
+
+  stage_3_args="$output_dir ${mender_disk_mappings[1]}"
+  ${tool_dir}/convert-stage-3.sh ${stage_3_args} || ret=$?
+  [[ $ret -ne 0 ]] && { return $ret; }
+
+  mount_mender_disk ${mender_disk_mappings[@]}
+
+  # Add mountpoints.
+  sudo install -d -m 755 ${sdimg_primary_dir}/boot/efi
+  sudo install -d -m 755 ${sdimg_primary_dir}/data
+
+  log "$step/$total Setting file system table..."
+  ((step++))
+  set_fstab $device_type
+
+  [[ $keep != "-k" ]] && { rm -f $output_dir/boot.vfat\
+     $output_dir/syslinux.cfg $output_dir/rootfs.img; }
+
+  return 0
+}
+
 do_install_mender_to_mender_disk_image() {
   log "$step/$total Installing Mender to Mender disk image..."
   ((step++))
@@ -499,10 +546,10 @@ do_install_bootloader_to_mender_disk_image() {
       { log "Error: incorrect device type. Aborting."; return 1; }
 
   case "$device_type" in
-    "beaglebone")
+    "beaglebone" | "qemux86_64")
       stage_5_args="-m $mender_disk_image -d $device_type -b ${bootloader_toolchain} $keep"
       eval set -- " ${stage_5_args}"
-      ${tool_dir}/bbb-convert-stage-5.sh ${stage_5_args}|| ret=$?
+      ${tool_dir}/convert-stage-5.sh ${stage_5_args}|| ret=$?
       [[ $ret -ne 0 ]] && { log "\nInstalling Bootloader failed."; return $ret; }
 
       # Update test configuration file
@@ -558,17 +605,18 @@ do_mender_disk_image_to_artifact() {
   [[ $inarray -eq 0 ]] && \
       { log "Error: invalid rootfs partition id provided. Aborting."; return 1; }
 
-  local count=
-  local bootstart=
-  local rootfs_a_start=
-  local rootfs_a_size=
-  local rootfs_b_start=
-  local rootfs_b_size=
+  local count=0
+  local prootfs_start=0
+  local prootfs_size=0
+  local rootfs_a_start=0
+  local rootfs_a_size=0
+  local rootfs_b_start=0
+  local rootfs_b_size=0
   local rootfs_path=
-  local sdimg_device_type=
+  local mender_device_type=
 
-  get_mender_disk_info $mender_disk_image count sector_size rootfs_a_start \
-                       rootfs_a_size rootfs_b_start rootfs_b_size
+  get_mender_disk_sizes $mender_disk_image count sector_size rootfs_a_start \
+                        rootfs_a_size rootfs_b_start rootfs_b_size
   ret=$?
   [[ $ret -ne 0 ]] && \
       { log "Error: cannot validate Mender disk image. Aborting."; return 1; }
@@ -801,21 +849,21 @@ case "$1" in
     do_raw_disk_image_create_partitions || rc=$?
     [[ $rc -ne 0 ]] && { log "Check $build_log for details."; exit 1; }
     log "A new Mender disk image with partition layout to support Mender has been successfully created!"
-    log "You can find the output Mender disk image at:\n\t${mender_disk_image}."
+    log "You can find the output Mender disk image at:\n\t${mender_disk_image}"
     ;;
   install-mender-to-mender-disk-image)
     total=1
     do_install_mender_to_mender_disk_image || rc=$?
     [[ $rc -ne 0 ]] && { log "Check $build_log for details."; exit 1; }
     log "The Mender client has been successfully installed to the Mender disk image."
-    log "You can find the output Mender disk image at:\n\t${mender_disk_image}."
+    log "You can find the output Mender disk image at:\n\t${mender_disk_image}"
     ;;
   install-bootloader-to-mender-disk-image)
     total=1
     do_install_bootloader_to_mender_disk_image || rc=$?
     [[ $rc -ne 0 ]] && { log "Check $build_log for details."; exit 1; }
     log "A bootloader configuration supporting dual A/B rootfs updates has been installed to the Mender disk image!"
-    log "You can find the output Mender disk image at:\n\t${mender_disk_image}."
+    log "You can find the output Mender disk image at:\n\t${mender_disk_image}"
     ;;
   mender-disk-image-to-artifact)
     total=1
diff --git a/mender-convert-functions.sh b/mender-convert-functions.sh
index 6afee9c..303fcbf 100755
--- a/mender-convert-functions.sh
+++ b/mender-convert-functions.sh
@@ -13,8 +13,12 @@ declare -i -r heads=255
 # Number of required sectors in a final image.
 declare -i -r sectors=63
 
-declare -a mender_disk_partitions=("boot" "primary" "secondary" "data")
-declare -a raw_disk_partitions=("boot" "rootfs")
+declare -a mender_partitions_regular=('boot' 'primary' 'secondary' 'data')
+declare -a mender_partitions_extended=('boot' 'primary' 'secondary' 'n/a' 'data' 'swap')
+declare -a raw_disk_partitions=('boot' 'rootfs')
+
+declare -A raw_disk_sizes
+declare -A mender_disk_sizes
 
 tool_dir="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
 files_dir=${tool_dir}/files
@@ -126,62 +130,58 @@ EOF
 # Calculates following values:
 #
 #  $2 - number of partitions
-#  $3 - size of the sector (in bytes)
-#  $4 - boot partition start offset (in sectors)
-#  $5 - boot partition size (in sectors)
-#  $6 - root filesystem partition start offset (in sectors)
-#  $7 - root filesystem partition size (in sectors)
-#  $8 - boot flag
-get_image_info() {
+#  $3 - sector size
+#  $4 - array of partitions' sizes for raw disk
+#
+get_raw_disk_sizes() {
   local limage=$1
   local rvar_count=$2
   local rvar_sectorsize=$3
-  local rvar_bootstart=$4
-  local rvar_bootsize=$5
-  local rvar_rootfsstart=$6
-  local rvar_rootfssize=$7
-  local rvar_bootflag=$8
-
-  local lbootsize=0
-  local lsubname=${limage:0:8}
-  local lfdisk="$(fdisk -u -l ${limage})"
+  shift 3
+  local rvar_array=($@)
 
+  local lsubname=${limage:0:10}
+  local lfdisk="$(fdisk -u -l ${limage})"
   local lparts=($(echo "${lfdisk}" | grep "^${lsubname}" | cut -d' ' -f1))
   local lcount=${#lparts[@]}
 
+  if [[ $lcount -gt 3 ]]; then
+    log "\tError: invalid/unsupported raw disk image. Aborting."
+    return 1
+  fi
+
   local lsectorsize=($(echo "${lfdisk}" | grep '^Sector' | cut -d' ' -f4))
 
-  local lfirstpartinfo="$(echo "${lfdisk}" | grep "^${lparts[0]}")"
+  local idx_start=2
+  local idx_size=4
 
-  idx_start=2
-  idx_size=4
+  local lfirstpartinfo="$(echo "${lfdisk}" | grep "^${lparts[0]}")"
 
   if [[ $lcount -gt 1 ]]; then
     local lsecondpartinfo="$(echo "${lfdisk}" | grep "^${lparts[1]}")"
-    local lsecondpartstart=($(echo "${lsecondpartinfo}" | tr -s ' ' | cut -d' ' -f${idx_start}))
-    local lsecondpartsize=($(echo "${lsecondpartinfo}" | tr -s ' ' | cut -d' ' -f${idx_size}))
+    eval $rvar_array[prootfs_start]="'$(echo "${lsecondpartinfo}" | tr -s ' ' | cut -d' ' -f${idx_start})'"
+    eval $rvar_array[prootfs_size]="'$(echo "${lsecondpartinfo}" | tr -s ' ' | cut -d' ' -f${idx_size})'"
+  fi
+
+  if [[ $lcount -gt 2 ]]; then
+    local lthirdpartinfo="$(echo "${lfdisk}" | grep "^${lparts[2]}")"
+    eval $rvar_array[pswap_start]="'$(echo "${lthirdpartinfo}" | tr -s ' ' | cut -d' ' -f${idx_start})'"
+    eval $rvar_array[pswap_size]="'$(echo "${lthirdpartinfo}" | tr -s ' ' | cut -d' ' -f${idx_size})'"
   fi
 
-  eval $rvar_bootflag="0"
+  # Check is first partition is marked as bootable.
   if [[ "$lfirstpartinfo" =~ .*\*.* ]]; then
-    eval $rvar_bootflag="1"
     ((idx_start+=1))
     ((idx_size+=1))
   fi
 
-  lfirstpartsize=($(echo "${lfirstpartinfo}" | tr -s ' ' | cut -d' ' -f${idx_size}))
-  lfirstpartstart=($(echo "${lfirstpartinfo}" | tr -s ' ' | cut -d' ' -f${idx_start}))
+  eval $rvar_array[pboot_start]="'$(echo "${lfirstpartinfo}" | tr -s ' ' | cut -d' ' -f${idx_start})'"
+  eval $rvar_array[pboot_size]="'$(echo "${lfirstpartinfo}" | tr -s ' ' | cut -d' ' -f${idx_size})'"
 
   eval $rvar_count="'$lcount'"
   eval $rvar_sectorsize="'$lsectorsize'"
-  eval $rvar_bootstart="'$lfirstpartstart'"
-  eval $rvar_bootsize="'$lfirstpartsize'"
-  eval $rvar_rootfsstart="'$lsecondpartstart'"
-  eval $rvar_rootfssize="'$lsecondpartsize'"
-
-  [[ $lcount -gt 2 ]] && \
-      { log "Unsupported type of source image. Aborting."; return 1; } || \
-      { return 0; }
+
+  return 0
 }
 
 # Takes the following argument
@@ -191,12 +191,12 @@ get_image_info() {
 #  $2 - partition alignment
 #  $3 - vfat storage offset
 
-set_boot_part_alignment() {
+set_mender_disk_alignment() {
   local rvar_partition_alignment=$2
   local rvar_vfat_storage_offset=$3
 
   case "$1" in
-    "beaglebone")
+    "beaglebone" | "qemux86_64")
       local lvar_partition_alignment=${PART_ALIGN_8MB}
       local lvar_vfat_storage_offset=$lvar_partition_alignment
       ;;
@@ -213,7 +213,7 @@ set_boot_part_alignment() {
 
 # Takes following arguments:
 #
-#  $1 - raw disk image path
+#  $1 - Mender disk image path
 #
 # Calculates following values:
 #
@@ -223,7 +223,7 @@ set_boot_part_alignment() {
 #  $5 - rootfs A partition size (in sectors)
 #  $6 - rootfs B partition start offset (in sectors)
 #  $7 - rootfs B partition size (in sectors)
-get_mender_disk_info() {
+get_mender_disk_sizes() {
   local limage=$1
   local rvar_count=$2
   local rvar_sectorsize=$3
@@ -232,13 +232,13 @@ get_mender_disk_info() {
   local rvar_rootfs_b_start=$6
   local rvar_rootfs_b_size=$7
 
-  local lsubname=${limage:0:8}
+  local lsubname=${limage:0:10}
   local lfdisk="$(fdisk -u -l ${limage})"
 
   local lparts=($(echo "${lfdisk}" | grep "^${lsubname}" | cut -d' ' -f1))
   local lcount=${#lparts[@]}
 
-  if [[ $lcount -ne 4 ]]; then
+  if [[ $lcount -ne 4 ]] && [[ $lcount -ne 6 ]]; then
     log "Error: invalid Mender disk image. Aborting."
     return 1
   else
@@ -290,83 +290,91 @@ align_partition_size() {
 
 # Takes following arguments:
 #
-#  $1 - raw_disk image
-#  $2 - partition alignment
-#  $3 - vfat storage offset
+#  $1 - number of partition of the raw disk image
+#  $2 - sector size of the raw disk image
+#  $3 - mender image partition alignment
+#  $4 - mender image's boot partition offset
+#  $5 - data partition size (in MB)
+#  $6 - array of partitions' sizes for raw image
 #
 # Returns:
 #
-#  $4 - boot partition start offset (in sectors)
-#  $5 - boot partition size (in sectors)
-#  $6 - root filesystem partition size (in sectors)
-#  $7 - sector size (in bytes)
-#  $8 - number of detected partitions
-analyse_raw_disk_image() {
-  local image=$1
-  local alignment=$2
-  local offset=$3
-  local count=
-  local sectorsize=
+#  $7 - array of partitions' sizes for Mender image
+#
+set_mender_disk_sizes() {
+  local count=$1
+  local sectorsize=$2
+  local alignment=$3
+  local offset=$4
+  local datasize=$(( ($5 * 1024 * 1024) / $2 ))
+  local _raw_sizes=$(declare -p $6)
+  eval "declare -A raw_sizes="${_raw_sizes#*=}
+  shift 6
+  local rvar_array=($@)
+
   local bootstart=
   local bootsize=
   local rootfsstart=
   local rootfssize=
   local bootflag=
 
-  local rvar_bootstart=$4
-  local rvar_bootsize=$5
-  local rvar_rootfssize=$6
-  local rvar_sectorsize=$7
-  local rvar_partitions=$8
-
-  get_image_info $image count sectorsize bootstart bootsize rootfsstart \
-                 rootfssize bootflag
-
-  [[ $? -ne 0 ]] && \
-      { log "Error: invalid/unsupported raw disk image. Aborting."; exit 1; }
-
   if [[ $count -eq 1 ]]; then
-    rootfssize=$bootsize
     # Default size of the boot partition: 16MiB.
     bootsize=$(( (${alignment} * 2) / ${sectorsize} ))
+    # Root filesystem size is determined by the size of the single partition.
+    rootfssize=${raw_sizes[pboot_size]}
+  else
+    bootsize=${raw_sizes[pboot_size]}
+    rootfssize=${raw_sizes[prootfs_size]}
   fi
 
   # Boot partition storage offset is defined from the top down.
   bootstart=$(( ${offset} / ${sectorsize} ))
 
   align_partition_size bootsize $sectorsize
-  align_partition_size rootfssize  $sectorsize
-
-  eval $rvar_bootstart="'$bootstart'"
-  eval $rvar_bootsize="'$bootsize'"
-  eval $rvar_rootfssize="'$rootfssize'"
-  eval $rvar_sectorsize="'$sectorsize'"
-  eval $rvar_partitions="'$count'"
+  align_partition_size rootfssize $sectorsize
+  align_partition_size datasize $sectorsize
+
+  eval $rvar_array[pboot_start]="'$bootstart'"
+  eval $rvar_array[pboot_size]="'$bootsize'"
+  eval $rvar_array[prootfs_size]="'$rootfssize'"
+  eval $rvar_array[pdata_size]="'$datasize'"
+
+  if [[ $count -eq 3 ]]; then
+    # Add space for Swap partition.
+    local swapsize=${raw_sizes[pswap_size]}
+    align_partition_size swapsize $sectorsize
+    eval $rvar_array[pswap_size]="'$swapsize'"
+  fi
 }
 
 # Takes following arguments:
 #
-#  $1 - boot partition start offset (in sectors)
-#  $2 - boot partition size (in sectors)
-#  $3 - root filesystem partition size (in sectors)
-#  $4 - data partition size (in MB)
-#  $5 - sector size (in bytes)
+#  $1 - sector size (in bytes)
+#  $2 - partition alignment
+#  $3 - array of partitions' sizes for Mender image
 #
 #  Returns:
 #
-#  $6 - aligned data partition size (in sectors)
-#  $7 - final .sdimg file size (in bytes)
+#  $4 - final Mender disk image size (in bytes)
+#
 calculate_mender_disk_size() {
-  local rvar_datasize=$6
-  local rvar_sdimgsize=$7
-
-  local datasize=$(( ($4 * 1024 * 1024) / $5 ))
-
-  align_partition_size datasize $5
-
-  local sdimgsize=$(( ($1 + $2 + 2 * ${3} +  $datasize) * $5 ))
+  local _mender_sizes=$(declare -p $3)
+  eval "declare -A mender_sizes="${_mender_sizes#*=}
+  local rvar_sdimgsize=$4
+
+  local sdimgsize=$(( (${mender_sizes[pboot_start]} + ${mender_sizes[pboot_size]} + \
+                       2 * ${mender_sizes[prootfs_size]} + \
+                       ${mender_sizes[pdata_size]}) * $1 ))
+
+  if [ -v mender_sizes[pswap_size] ]; then
+     log "\tSwap partition found."
+     # Add size of the swap partition to the total size.
+     sdimgsize=$(( $sdimgsize + (${mender_sizes[pswap_size]} * $1) ))
+     # Add alignment used as swap partition offset.
+     sdimgsize=$(( $sdimgsize + 2 * ${2} ))
+  fi
 
-  eval $rvar_datasize="'$datasize'"
   eval $rvar_sdimgsize="'$sdimgsize'"
 }
 
@@ -396,35 +404,55 @@ create_mender_disk() {
 
 # Takes following arguments:
 #
-#  $1 - raw disk image path
-#  $2 - raw disk image size
-#  $3 - boot partition start offset
-#  $4 - boot partition size
-#  $5 - root filesystem partiotion size
-#  $6 - data partition size
-#  $7 - sector size
+#  $1 - Mender disk image path
+#  $2 - Mender disk image size
+#  $3 - sector size in bytes
+#  $4 - partition alignment
+#  $5 - array of partitions' sizes for Mender image
+#
+#  Returns:
+#
+#  $6 - number of partitions of the Mender disk image
+#
 format_mender_disk() {
   local lfile=$1
   local lsize=$2
+  local sectorsize=$3
+  local alignment=$(($4 / ${sectorsize}))
+  local rc=0
+
+  local _mender_sizes=$(declare -p $5)
+  eval "declare -A mender_sizes="${_mender_sizes#*=}
+  local rvar_counts=$6
+
+  cylinders=$(( ${lsize} / ${heads} / ${sectors} / ${sectorsize} ))
+
+  pboot_start=${mender_sizes[pboot_start]}
+  pboot_size=${mender_sizes[pboot_size]}
+  pboot_end=$((${pboot_start} + ${pboot_size} - 1))
+
+  prootfs_size=${mender_sizes[prootfs_size]}
+
+  prootfsa_start=$((${pboot_end} + 1))
+  prootfsa_end=$((${prootfsa_start} + ${prootfs_size} - 1))
+
+  prootfsb_start=$((${prootfsa_end} + 1))
+  prootfsb_end=$((${prootfsb_start} + ${prootfs_size} - 1))
+
+  pdata_start=$((${prootfsb_end} + 1))
+  pdata_size=${mender_sizes[pdata_size]}
+  pdata_end=$((${pdata_start} + ${pdata_size} - 1))
+
+  if [ -v mender_sizes[pswap_size] ]; then
+    local pextended_start=$((${prootfsb_end} + 1))
 
-#  if [ -z "$3" ]; then
-#    echo "Error: no root filesystem size provided"
-#    exit 1
-#  fi
-
-#  if [ -z "$2" ]; then
-#    size=$(sudo blockdev --getsize64 ${sdimg_file})
-#  else
-#    size=$2
-#  fi
-
-  cylinders=$(( ${lsize} / ${heads} / ${sectors} / ${7} ))
-  rootfs_size=$(( $5 - 1 ))
-  pboot_offset=$(( ${4} - 1 ))
-  primary_start=$(( ${3} + ${pboot_offset} + 1 ))
-  secondary_start=$(( ${primary_start} + ${rootfs_size} + 1 ))
-  data_start=$(( ${secondary_start} + ${rootfs_size} + 1 ))
-  data_offset=$(( ${6} - 1 ))
+    pdata_start=$(($pextended_start + ${alignment}))
+    pdata_end=$((${pdata_start} + ${pdata_size} - 1))
+
+    local pswap_start=$((${pdata_end} + ${alignment} + 1))
+    local pswap_size=${mender_sizes[pswap_size]}
+    local pswap_end=$((${pswap_start} + ${pswap_size} - 1))
+  fi
 
   sed -e 's/\s*\([\+0-9a-zA-Z]*\).*/\1/' << EOF | sudo fdisk ${lfile} &> /dev/null
 	o # clear the in memory partition table
@@ -436,56 +464,49 @@ format_mender_disk() {
 	c
 	${cylinders}
 	r
-	n # new partition
-	p # primary partition
-	1 # partition number 1
-	${3}  # default - start at beginning of disk
-	+${pboot_offset} # 16 MB boot parttion
-	t
-	c
-	a
-	n # new partition
-	p # primary partition
-	2 # partion number 2
-	${primary_start}	# start immediately after preceding partition
-	+${rootfs_size}
-	n # new partition
-	p # primary partition
-	3 # partion number 3
-	${secondary_start}	# start immediately after preceding partition
-	+${rootfs_size}
-	n # new partition
-	p # primary partition
-	${data_start}		# start immediately after preceding partition
-	+${data_offset}
-	p # print the in-memory partition table
 	w # write the partition table
 	q # and we're done
 EOF
-  log "\tChanges in partition table applied."
+
+  # Create partition table
+  sudo parted -s ${lfile} mklabel msdos || rc=$?
+  sudo parted -s ${lfile} unit s mkpart primary fat32 ${pboot_start} ${pboot_end} || rc=$?
+  sudo parted -s ${lfile} set 1 boot on || rc=$?
+  sudo parted -s ${lfile} -- unit s mkpart primary ext4 ${prootfsa_start} ${prootfsa_end} || rc=$?
+  sudo parted -s ${lfile} -- unit s mkpart primary ext4 ${prootfsb_start} ${prootfsb_end} || rc=$?
+
+  if [ -v mender_sizes[pswap_size] ]; then
+    log "\tAdding swap partition."
+    sudo parted -s ${lfile} -- unit s mkpart extended ${pextended_start} 100% || rc=$?
+    sudo parted -s ${lfile} -- unit s mkpart logical ext4 ${pdata_start} ${pdata_end} || rc=$?
+    sudo parted -s ${lfile} -- unit s mkpart logical linux-swap ${pswap_start} ${pswap_end} || rc=$?
+    eval $rvar_counts="'6'"
+  else
+    sudo parted -s ${lfile} -- unit s mkpart primary ext4 ${pdata_start} ${pdata_end} || rc=$?
+    eval $rvar_counts="'4'"
+  fi
+
+  [[ $rc -eq 0 ]] && { log "\tChanges in partition table applied."; }
+
+  return $rc
 }
 
 # Takes following arguments:
 #
 #  $1 - raw disk file
 #
-# Returns:
-#
-#  $2 - number of detected partitions
 verify_mender_disk() {
   local lfile=$1
-  local rvar_no_of_parts=$2
+  local lcounts=$2
 
   local limage=$(basename $lfile)
   local partitions=($(fdisk -l -u ${limage} | cut -d' ' -f1 | grep 'sdimg[1-9]\{1\}$'))
 
   local no_of_parts=${#partitions[@]}
 
-  [[ $no_of_parts -eq 4 ]] || \
+  [[ $no_of_parts -eq $lcounts ]] || \
       { log "Error: incorrect number of partitions: $no_of_parts. Aborting."; return 1; }
 
-  eval $rvar_no_of_parts=="'$no_of_parts='"
-
   return 0
 }
 
@@ -535,23 +556,52 @@ detach_device_maps() {
 # Takes following arguments:
 #
 #  $1 - partition mappings holder
+#
 make_mender_disk_filesystem() {
   local mappings=($@)
+  local counts=${#mappings[@]}
+
+  if [ $counts -eq 4 ]; then
+    local labels=(${mender_partitions_regular[@]})
+  elif [ $counts -eq 6 ]; then
+    local labels=(${mender_partitions_extended[@]})
+  fi
 
   for mapping in ${mappings[@]}
   do
     map_dev=/dev/mapper/"$mapping"
     part_no=$(get_part_number_from_device $map_dev)
+    label=${labels[${part_no} - 1]}
 
-    label=${mender_disk_partitions[${part_no} - 1]}
-
-    if [[ part_no -eq 1 ]]; then
-      log "\tCreating MS-DOS filesystem for '$label' partition."
-      sudo mkfs.vfat -n ${label} $map_dev >> "$build_log" 2>&1
-    else
-      log "\tCreating ext4 filesystem for '$label' partition."
-      sudo mkfs.ext4 -L ${label} $map_dev >> "$build_log" 2>&1
-    fi
+    case ${part_no} in
+      1)
+        log "\tCreating MS-DOS filesystem for '$label' partition."
+        sudo mkfs.vfat -n ${label} $map_dev >> "$build_log" 2>&1
+        ;;
+      2|3)
+        log "\tCreating ext4 filesystem for '$label' partition."
+        sudo mkfs.ext4 -L ${label} $map_dev >> "$build_log" 2>&1
+        ;;
+      4)
+        if [ $counts -eq 4 ]; then
+          log "\tCreating ext4 filesystem for '$label' partition."
+          sudo mkfs.ext4 -L ${label} $map_dev >> "$build_log" 2>&1
+        else
+          continue
+        fi
+        ;;
+      5)
+        log "\tCreating ext4 filesystem for '$label' partition."
+        sudo mkfs.ext4 -L ${label} $map_dev >> "$build_log" 2>&1
+        ;;
+      6)
+        log "\tCreating swap area for '$label' partition."
+        sudo mkswap -L ${label} $map_dev >> "$build_log" 2>&1
+        ;;
+      *)
+        break
+        ;;
+    esac
   done
 }
 
@@ -582,13 +632,44 @@ mount_raw_disk() {
 #  $1 - partition mappings holder
 mount_mender_disk() {
   local mappings=($@)
+  local counts=${#mappings[@]}
+
+  if [ $counts -eq 4 ]; then
+    local labels=(${mender_partitions_regular[@]})
+  elif [ $counts -eq 6 ]; then
+    local labels=(${mender_partitions_extended[@]})
+  fi
 
   for mapping in ${mappings[@]}
   do
     local part_no=${mapping#*p*p}
-    local path=$sdimg_base_dir/${mender_disk_partitions[${part_no} - 1]}
+    local path=$sdimg_base_dir/${labels[${part_no} - 1]}
     mkdir -p $path
-    sudo mount /dev/mapper/"${mapping}" $path 2>&1 >/dev/null
+
+    case ${part_no} in
+      1|2|3)
+        sudo mount /dev/mapper/"${mapping}" $path 2>&1 >/dev/null
+        ;;
+      4)
+        if [ $counts -eq 4 ]; then
+          sudo mount /dev/mapper/"${mapping}" $path 2>&1 >/dev/null
+        else
+          # Skip extended partition.
+          continue
+        fi
+        ;;
+      5)
+        sudo mount /dev/mapper/"${mapping}" $path 2>&1 >/dev/null
+        ;;
+      6)
+        # Skip swap partition.
+        continue
+        ;;
+      *)
+        break
+        ;;
+    esac
+
   done
 }
 
@@ -597,6 +678,8 @@ mount_mender_disk() {
 #  $1 - device type
 set_fstab() {
   local mountpoint=
+  local blk_device=
+  local data_id=4
   local device_type=$1
   local sysconfdir="$sdimg_primary_dir/etc"
 
@@ -608,9 +691,16 @@ set_fstab() {
   case "$device_type" in
     "beaglebone")
       mountpoint="/boot/efi"
+      blk_device=mmcblk0p
       ;;
     "raspberrypi3")
       mountpoint="/uboot"
+      blk_device=mmcblk0p
+      ;;
+    "qemux86_64")
+      mountpoint="/boot/efi"
+      blk_device=hda
+      data_id=5
       ;;
   esac
 
@@ -628,10 +718,15 @@ set_fstab() {
 	#/dev/mmcblk0p1       /media/card          auto       defaults,sync,noauto  0  0
 
 	# Where the U-Boot environment resides; for devices with SD card support ONLY!
-	/dev/mmcblk0p1   $mountpoint          auto       defaults,sync    0  0
-	/dev/mmcblk0p4   /data                auto       defaults         0  0
+	/dev/${blk_device}1   $mountpoint          auto       defaults,sync    0  0
+	/dev/${blk_device}${data_id}   /data          auto       defaults         0  0
 	EOF"
 
+  if [ "$device_type" == "qemux86_64" ]; then
+    # Add entry referring to swap partition.
+    sudo tee -a ${sysconfdir}/fstab <<< "/dev/hda6       swap    swap    defaults        0       0" 2>&1 >/dev/null
+  fi
+
   log "\tDone."
 }
 
@@ -653,21 +748,20 @@ extract_file_from_image() {
 #
 #  $1 - device type
 #  $2 - partition alignment in bytes
-#  $3 - boot partition storage offset in bytes
-#  $4 - boot partition size in sectors
-#  $5 - rootfs partition size in sectors
-#  $6 - data partition size in sectors
-#  $7 - complete image size in bytes
-#  $8 - sector size in bytes
-
+#  $3 - total size in bytes
+#  $4 - sector size in bytes
+#  $5 - array of partitions' sizes for Mender image
+#
 create_test_config_file() {
   local device_type=$1
   local alignment=$2
-  local boot_offset=$3
-  local boot_size_mb=$(( ((($4 * $8) / 1024) / 1024) ))
-  local rootfs_size_mb=$(( ((($5 * $8) / 1024) / 1024) ))
-  local data_size_mb=$(( ((($6 * $8) / 1024) / 1024) ))
-  local mender_image_size_mb=$(( (($7 / 1024) / 1024) ))
+  local mender_image_size_mb=$(( (($3 / 1024) / 1024) ))
+  local _mender_sizes=$(declare -p $5)
+  eval "declare -A mender_sizes="${_mender_sizes#*=}
+  local boot_offset=$(( (${mender_sizes[pboot_start]} * $4) ))
+  local boot_size_mb=$(( (((${mender_sizes[pboot_size]} * $4) / 1024) / 1024) ))
+  local rootfs_size_mb=$(( (((${mender_sizes[prootfs_size]} * $4) / 1024) / 1024) ))
+  local data_size_mb=$(( (((${mender_sizes[pdata_size]} * $4) / 1024) / 1024) ))
 
   cp ${files_dir}/variables.template ${output_dir}/${device_type}_variables.cfg
 
diff --git a/qemux86_64-convert-stage-2.sh b/qemux86_64-convert-stage-2.sh
new file mode 100755
index 0000000..ffad07f
--- /dev/null
+++ b/qemux86_64-convert-stage-2.sh
@@ -0,0 +1,21 @@
+#!/bin/bash
+
+output_dir=$1
+boot_mapping=$2
+build_log=$output_dir/build.log
+
+[ ! -f $output_dir/boot.vfat ] && \
+    { log "Error: extracted boot partition not found. Aborting."; exit 1; }
+
+# Make a copy of Linux kernel arguments and modify.
+mcopy -on -i ${output_dir}/boot.vfat -s ::EFI/BOOT/grub.cfg ${output_dir}/grub.cfg
+sed -i 's/\b[ ]root=[^ ]*/ root=\/dev\/hda2/' ${output_dir}/grub.cfg
+
+# Update Linux kernel command arguments with our custom configuration
+mcopy -o -i ${output_dir}/boot.vfat -s ${output_dir}/grub.cfg ::EFI/BOOT/grub.cfg
+
+sudo dd if=${output_dir}/boot.vfat of=/dev/mapper/${boot_mapping} bs=1M >> "$build_log" 2>&1
+
+log "\tDone."
+
+exit 0
diff --git a/rpi3-convert-stage-5.sh b/rpi3-convert-stage-5.sh
index 888ca9b..3a9008b 100755
--- a/rpi3-convert-stage-5.sh
+++ b/rpi3-convert-stage-5.sh
@@ -25,7 +25,7 @@ GCC_VERSION="6.3.1"
 build_log=${output_dir}/build.log
 
 declare -a mender_disk_mappings
-declare -a mender_disk_partitions=("boot" "primary" "secondary" "data")
+declare -a mender_partitions_regular=("boot" "primary" "secondary" "data")
 
 version() {
   echo "$@" | awk -F. '{ printf("%d%03d%03d\n", $1,$2,$3); }'