Monorepo for Aesthetic.Computer aesthetic.computer
4
fork

Configure Feed

Select the types of activity you want to include in your feed.

Fix native install source and credentials

+206 -74
+49
fedac/native/ac-os
··· 710 710 "${repo_root}" >/dev/null 711 711 } 712 712 713 + usb_part_path() { 714 + local dev="$1" 715 + local idx="$2" 716 + if [[ "${dev}" =~ [0-9]$ ]]; then 717 + printf '%sp%s\n' "${dev}" "${idx}" 718 + else 719 + printf '%s%s\n' "${dev}" "${idx}" 720 + fi 721 + } 722 + 723 + preserve_existing_usb_wifi_creds() { 724 + local USB_DEV="$1" 725 + local OUTPUT_FILE="$2" 726 + local MOUNT_DIR 727 + 728 + MOUNT_DIR="$(mktemp -d /tmp/ac-usb-preserve.XXXXXX)" 729 + 730 + for idx in 1 2 3 4; do 731 + local PART 732 + PART="$(usb_part_path "${USB_DEV}" "${idx}")" 733 + [ -b "${PART}" ] || continue 734 + 735 + if ! sudo mount -t vfat -o ro "${PART}" "${MOUNT_DIR}" 2>/dev/null; then 736 + continue 737 + fi 738 + 739 + if [ -f "${MOUNT_DIR}/wifi_creds.json" ]; then 740 + if sudo cp "${MOUNT_DIR}/wifi_creds.json" "${OUTPUT_FILE}"; then 741 + sudo chown "$(id -u):$(id -g)" "${OUTPUT_FILE}" 2>/dev/null || true 742 + sudo umount "${MOUNT_DIR}" >/dev/null 2>&1 || true 743 + rmdir "${MOUNT_DIR}" 2>/dev/null || true 744 + log "Preserved wifi_creds.json from ${PART}" 745 + return 0 746 + fi 747 + fi 748 + 749 + sudo umount "${MOUNT_DIR}" >/dev/null 2>&1 || true 750 + done 751 + 752 + rmdir "${MOUNT_DIR}" 2>/dev/null || true 753 + return 1 754 + } 755 + 713 756 require_login() { 714 757 # Require ac-login before flashing — ensures builds are tied to an authenticated user 715 758 local TOKEN_FILE="${HOME}/.ac-token" ··· 951 994 local CONFIG_FILE 952 995 local STAGE_ROOT 953 996 local CONTAINER 997 + local WIFI_CREDS_FILE 954 998 955 999 USB_DEV="$(find_usb_dev)" || { err "No USB device found"; exit 1; } 956 1000 log "Flashing to ${USB_DEV}..." ··· 958 1002 MEDIA_TMP="$(mktemp -d /tmp/ac-media.XXXXXX)" 959 1003 CONFIG_FILE="${MEDIA_TMP}/config.json" 960 1004 STAGE_ROOT="${MEDIA_TMP}/staged-root" 1005 + WIFI_CREDS_FILE="${MEDIA_TMP}/wifi_creds.json" 961 1006 cleanup_flash_usb() { 962 1007 if [ -n "${CONTAINER:-}" ]; then 963 1008 sudo docker rm -f "${CONTAINER}" >/dev/null 2>&1 || true ··· 966 1011 } 967 1012 968 1013 write_usb_config_file "${CONFIG_FILE}" 1014 + preserve_existing_usb_wifi_creds "${USB_DEV}" "${WIFI_CREDS_FILE}" || true 969 1015 970 1016 ac_media_stage_boot_tree "${STAGE_ROOT}" "${VMLINUZ}" "${CONFIG_FILE}" 1017 + if [ -f "${WIFI_CREDS_FILE}" ]; then 1018 + cp "${WIFI_CREDS_FILE}" "${STAGE_ROOT}/wifi_creds.json" 1019 + fi 971 1020 972 1021 ensure_media_helper_image 973 1022 CONTAINER=$(sudo docker create --rm --privileged -v /dev:/dev \
+5 -2
fedac/native/scripts/flash-helper-runner.sh
··· 188 188 if [ "${include_config}" = "yes" ]; then 189 189 cp "${STAGED_ROOT}/config.json" "${mountpoint}/config.json" 190 190 fi 191 + if [ -f "${STAGED_ROOT}/wifi_creds.json" ]; then 192 + cp "${STAGED_ROOT}/wifi_creds.json" "${mountpoint}/wifi_creds.json" 193 + fi 191 194 sync 192 195 umount "${mountpoint}" 193 196 } ··· 351 354 # If slim kernel isn't available, falls back to chainloader mode. 352 355 if [ -f "${STAGED_ROOT}/EFI/BOOT/KERNEL-SLIM.EFI" ] && [ -f "${STAGED_ROOT}/initramfs.cpio.gz" ]; then 353 356 log "Using universal boot: splash → systemd-boot → slim kernel + initramfs" 354 - copy_boot_tree_to_vfat "${EFI_PART}" /mnt/ac-efi no systemd-boot 357 + copy_boot_tree_to_vfat "${EFI_PART}" /mnt/ac-efi yes systemd-boot 355 358 else 356 359 log "No slim kernel — using chainloader mode (ThinkPad only)" 357 - copy_boot_tree_to_vfat "${EFI_PART}" /mnt/ac-efi no chainloader 360 + copy_boot_tree_to_vfat "${EFI_PART}" /mnt/ac-efi yes chainloader 358 361 fi 359 362 populate_mac_partition "${MAC_PART}" /mnt/ac-mac 360 363
+152 -72
fedac/native/src/ac-native.c
··· 927 927 return -1; 928 928 } 929 929 930 + // Score removable install sources by how much of the current boot payload they 931 + // contain. Higher scores are preferred during W-to-install so we choose the 932 + // universal ACEFI partition over the simpler ACBOOT fallback when both exist. 933 + // 3 = universal layout (BOOTX64 + LOADER + KERNEL + initramfs + loader entry) 934 + // 2 = chainloader layout (BOOTX64 + KERNEL) 935 + // 1 = monolithic layout (BOOTX64 only) 936 + // 0 = not a usable install source 937 + static int install_source_layout_score(const char *mountpoint) { 938 + char bootx64[128]; 939 + char loader[128]; 940 + char kernel[128]; 941 + char initramfs_gz[128]; 942 + char initramfs_lz4[128]; 943 + char loader_entry[160]; 944 + 945 + snprintf(bootx64, sizeof(bootx64), "%s/EFI/BOOT/BOOTX64.EFI", mountpoint); 946 + snprintf(loader, sizeof(loader), "%s/EFI/BOOT/LOADER.EFI", mountpoint); 947 + snprintf(kernel, sizeof(kernel), "%s/EFI/BOOT/KERNEL.EFI", mountpoint); 948 + snprintf(initramfs_gz, sizeof(initramfs_gz), "%s/initramfs.cpio.gz", mountpoint); 949 + snprintf(initramfs_lz4, sizeof(initramfs_lz4), "%s/initramfs.cpio.lz4", mountpoint); 950 + snprintf(loader_entry, sizeof(loader_entry), "%s/loader/entries/ac-native.conf", mountpoint); 951 + 952 + if (access(bootx64, F_OK) == 0 && 953 + access(loader, F_OK) == 0 && 954 + access(kernel, F_OK) == 0 && 955 + (access(initramfs_gz, F_OK) == 0 || access(initramfs_lz4, F_OK) == 0) && 956 + access(loader_entry, F_OK) == 0) { 957 + return 3; 958 + } 959 + if (access(bootx64, F_OK) == 0 && access(kernel, F_OK) == 0) return 2; 960 + if (access(bootx64, F_OK) == 0) return 1; 961 + return 0; 962 + } 963 + 930 964 // Auto-install kernel to internal drive's EFI System Partition 931 965 // Returns 1 on success, 0 on failure (sets install_fail_reason/detail). 932 966 static int auto_install_to_hd(ACGraph *graph, ACFramebuffer *screen, ··· 938 972 install_fail_reason[0] = '\0'; 939 973 install_fail_detail[0] = '\0'; 940 974 char bootloader_src[96] = ""; 975 + char loader_src[96] = ""; 941 976 char chain_kernel_src[96] = ""; 977 + char initramfs_src[96] = ""; 942 978 char install_kernel_src[96] = ""; 943 979 char config_src[64] = ""; 980 + char loader_conf_src[96] = ""; 981 + char loader_entry_src[128] = ""; 944 982 945 983 ac_log("[install] auto_install_to_hd starting\n"); 946 984 if (display) 947 985 draw_boot_status(graph, screen, display, "installing to disk...", pixel_scale); 948 986 949 987 // Detect source layout: monolithic (BOOTX64.EFI is kernel), chainloader 950 - // (BOOTX64.EFI boots KERNEL.EFI), or systemd-boot (kernel at EFI/Linux/*). 988 + // (BOOTX64.EFI boots KERNEL.EFI), or universal systemd-boot 989 + // (BOOTX64.EFI + LOADER.EFI + KERNEL.EFI + initramfs + loader entry). 951 990 int systemd_boot_layout = 0; 952 991 int chainloader_layout = 0; 992 + int source_score = 0; 953 993 954 - // Prefer current /mnt only when it is removable and has a bootable layout. 994 + // Prefer current /mnt only when it is removable and actually bootable. 955 995 if (log_dev[0]) { 956 996 char blk[32] = ""; 957 997 get_parent_block(log_dev + 5, blk, sizeof(blk)); 958 - if (blk[0] && is_removable(blk) == 1 && 959 - (access("/mnt/EFI/BOOT/BOOTX64.EFI", F_OK) == 0 || 960 - access("/mnt/EFI/BOOT/KERNEL.EFI", F_OK) == 0 || 961 - access("/mnt/EFI/Linux/vmlinuz-ac-native", F_OK) == 0)) { 962 - strncpy(source_dev, log_dev, sizeof(source_dev) - 1); 963 - source_dev[sizeof(source_dev) - 1] = '\0'; 998 + if (blk[0] && is_removable(blk) == 1) { 999 + source_score = install_source_layout_score("/mnt"); 1000 + if (source_score > 0) { 1001 + ac_log("[install] current /mnt source score=%d (%s)\n", source_score, log_dev); 1002 + strncpy(source_dev, log_dev, sizeof(source_dev) - 1); 1003 + source_dev[sizeof(source_dev) - 1] = '\0'; 1004 + } 964 1005 } 965 1006 } 966 1007 967 - // Fallback: scan removable partitions for bootable layout 968 - if (!source_dev[0]) { 1008 + // Scan removable partitions and prefer the richest boot layout. This lets 1009 + // W-install source from ACEFI on the new hybrid USB instead of blindly 1010 + // using whichever removable partition happened to get mounted at /mnt. 1011 + { 969 1012 const char *src_candidates[] = { 970 - "/dev/sda1", "/dev/sdb1", "/dev/sdc1", "/dev/sdd1", NULL 1013 + "/dev/sda1", "/dev/sda2", 1014 + "/dev/sdb1", "/dev/sdb2", 1015 + "/dev/sdc1", "/dev/sdc2", 1016 + "/dev/sdd1", "/dev/sdd2", 1017 + NULL 971 1018 }; 1019 + char best_dev[32] = ""; 1020 + int best_score = source_score; 972 1021 mkdir("/tmp/src", 0755); 973 1022 for (int i = 0; src_candidates[i]; i++) { 974 1023 if (access(src_candidates[i], F_OK) != 0) continue; 1024 + if (source_dev[0] && strcmp(src_candidates[i], source_dev) == 0) continue; 975 1025 char blk[32] = ""; 976 1026 get_parent_block(src_candidates[i] + 5, blk, sizeof(blk)); 977 1027 if (!blk[0] || is_removable(blk) != 1) continue; 978 1028 if (mount(src_candidates[i], "/tmp/src", "vfat", 0, NULL) != 0) continue; 979 - if (access("/tmp/src/EFI/BOOT/BOOTX64.EFI", F_OK) == 0 || 980 - access("/tmp/src/EFI/BOOT/KERNEL.EFI", F_OK) == 0 || 981 - access("/tmp/src/EFI/Linux/vmlinuz-ac-native", F_OK) == 0) { 982 - strncpy(source_dev, src_candidates[i], sizeof(source_dev) - 1); 1029 + int score = install_source_layout_score("/tmp/src"); 1030 + umount("/tmp/src"); 1031 + if (score > best_score) { 1032 + best_score = score; 1033 + strncpy(best_dev, src_candidates[i], sizeof(best_dev) - 1); 1034 + best_dev[sizeof(best_dev) - 1] = '\0'; 1035 + } 1036 + } 1037 + if (best_dev[0]) { 1038 + if (mount(best_dev, "/tmp/src", "vfat", 0, NULL) == 0) { 1039 + strncpy(source_dev, best_dev, sizeof(source_dev) - 1); 983 1040 source_dev[sizeof(source_dev) - 1] = '\0'; 984 1041 strncpy(source_mount, "/tmp/src", sizeof(source_mount) - 1); 985 1042 source_mount[sizeof(source_mount) - 1] = '\0'; 986 1043 source_mounted_tmp = 1; 987 - break; 1044 + source_score = best_score; 1045 + ac_log("[install] selected richer removable source %s score=%d\n", 1046 + source_dev, source_score); 1047 + } else { 1048 + ac_log("[install] failed to mount preferred source %s errno=%d\n", 1049 + best_dev, errno); 988 1050 } 989 - umount("/tmp/src"); 990 1051 } 991 1052 } 992 1053 993 - // Detect systemd-boot layout (separate kernel + initramfs + loader config) 994 - { 995 - char sbl_check[128]; 996 - snprintf(sbl_check, sizeof(sbl_check), "%s/EFI/Linux/vmlinuz-ac-native", source_mount); 997 - if (access(sbl_check, F_OK) == 0) { 998 - systemd_boot_layout = 1; 999 - ac_log("[install] Detected systemd-boot layout\n"); 1000 - } 1001 - } 1054 + systemd_boot_layout = (source_score >= 3); 1055 + chainloader_layout = (!systemd_boot_layout && source_score >= 2); 1002 1056 1003 1057 snprintf(bootloader_src, sizeof(bootloader_src), "%s/EFI/BOOT/BOOTX64.EFI", source_mount); 1058 + snprintf(loader_src, sizeof(loader_src), "%s/EFI/BOOT/LOADER.EFI", source_mount); 1004 1059 snprintf(chain_kernel_src, sizeof(chain_kernel_src), "%s/EFI/BOOT/KERNEL.EFI", source_mount); 1005 1060 snprintf(kernel_src, sizeof(kernel_src), "%s/EFI/BOOT/BOOTX64.EFI", source_mount); 1006 1061 snprintf(config_src, sizeof(config_src), "%s/config.json", source_mount); 1007 - if (!systemd_boot_layout && access(chain_kernel_src, F_OK) == 0) { 1008 - chainloader_layout = 1; 1062 + snprintf(loader_conf_src, sizeof(loader_conf_src), "%s/loader/loader.conf", source_mount); 1063 + snprintf(loader_entry_src, sizeof(loader_entry_src), "%s/loader/entries/ac-native.conf", source_mount); 1064 + if (access(source_dev, F_OK) == 0 && systemd_boot_layout) { 1065 + char initramfs_gz[96]; 1066 + char initramfs_lz4[96]; 1067 + snprintf(initramfs_gz, sizeof(initramfs_gz), "%s/initramfs.cpio.gz", source_mount); 1068 + snprintf(initramfs_lz4, sizeof(initramfs_lz4), "%s/initramfs.cpio.lz4", source_mount); 1069 + if (access(initramfs_gz, F_OK) == 0) { 1070 + strncpy(initramfs_src, initramfs_gz, sizeof(initramfs_src) - 1); 1071 + initramfs_src[sizeof(initramfs_src) - 1] = '\0'; 1072 + } else if (access(initramfs_lz4, F_OK) == 0) { 1073 + strncpy(initramfs_src, initramfs_lz4, sizeof(initramfs_src) - 1); 1074 + initramfs_src[sizeof(initramfs_src) - 1] = '\0'; 1075 + } 1076 + } 1077 + 1078 + if (systemd_boot_layout) { 1009 1079 strncpy(install_kernel_src, chain_kernel_src, sizeof(install_kernel_src) - 1); 1010 1080 install_kernel_src[sizeof(install_kernel_src) - 1] = '\0'; 1011 - ac_log("[install] Detected chainloader layout\n"); 1012 - } else if (systemd_boot_layout) { 1013 - snprintf(install_kernel_src, sizeof(install_kernel_src), "%s/EFI/Linux/vmlinuz-ac-native", 1014 - source_mount); 1081 + ac_log("[install] detected universal systemd-boot layout\n"); 1082 + } else if (chainloader_layout) { 1083 + strncpy(install_kernel_src, chain_kernel_src, sizeof(install_kernel_src) - 1); 1084 + install_kernel_src[sizeof(install_kernel_src) - 1] = '\0'; 1085 + ac_log("[install] detected chainloader layout\n"); 1015 1086 } else { 1016 1087 strncpy(install_kernel_src, kernel_src, sizeof(install_kernel_src) - 1); 1017 1088 install_kernel_src[sizeof(install_kernel_src) - 1] = '\0'; 1089 + if (source_score == 1) ac_log("[install] detected monolithic layout\n"); 1018 1090 } 1019 1091 1020 - if (!source_dev[0] || 1021 - ((access(kernel_src, F_OK) != 0 && access(chain_kernel_src, F_OK) != 0) && 1022 - !systemd_boot_layout)) { 1092 + if (!source_dev[0] || source_score == 0 || 1093 + access(install_kernel_src, F_OK) != 0 || 1094 + (systemd_boot_layout && 1095 + (access(loader_src, F_OK) != 0 || 1096 + initramfs_src[0] == '\0' || 1097 + access(loader_entry_src, F_OK) != 0))) { 1023 1098 ac_log("[install] No removable install source with kernel found\n"); 1024 1099 snprintf(install_fail_reason, sizeof(install_fail_reason), 1025 1100 "no USB boot source found"); ··· 1100 1175 mkdir("/tmp/hd/EFI", 0755); 1101 1176 mkdir("/tmp/hd/EFI/BOOT", 0755); 1102 1177 1103 - // Check free space and kernel size before copy 1178 + // Check free space against the full payload we plan to copy. 1104 1179 { 1105 - struct stat ksrc_st; 1180 + struct stat src_st; 1106 1181 struct statvfs hd_vfs; 1107 - long kernel_bytes = 0, free_mb = 0; 1108 - if (stat(install_kernel_src, &ksrc_st) == 0) kernel_bytes = ksrc_st.st_size; 1182 + long long install_bytes = 0; 1183 + long long free_bytes = 0; 1184 + if (stat(install_kernel_src, &src_st) == 0) install_bytes += src_st.st_size; 1185 + if (chainloader_layout && stat(bootloader_src, &src_st) == 0) install_bytes += src_st.st_size; 1186 + if (systemd_boot_layout) { 1187 + if (stat(bootloader_src, &src_st) == 0) install_bytes += src_st.st_size; 1188 + if (stat(loader_src, &src_st) == 0) install_bytes += src_st.st_size; 1189 + if (stat(initramfs_src, &src_st) == 0) install_bytes += src_st.st_size; 1190 + if (stat(loader_conf_src, &src_st) == 0) install_bytes += src_st.st_size; 1191 + if (stat(loader_entry_src, &src_st) == 0) install_bytes += src_st.st_size; 1192 + } 1193 + if (stat(config_src, &src_st) == 0) install_bytes += src_st.st_size; 1109 1194 if (statvfs("/tmp/hd", &hd_vfs) == 0) 1110 - free_mb = (long)hd_vfs.f_bavail * (long)hd_vfs.f_bsize / 1048576; 1111 - ac_log("[install] kernel=%ldMB free=%ldMB on %s\n", 1112 - kernel_bytes / 1048576, free_mb, devpath); 1113 - if (kernel_bytes > 0 && free_mb < kernel_bytes / 1048576 + 10) { 1114 - long need_mb = kernel_bytes / 1048576 + 10; 1195 + free_bytes = (long long)hd_vfs.f_bavail * (long long)hd_vfs.f_bsize; 1196 + long need_mb = (long)((install_bytes + (1048576 - 1)) / 1048576) + 10; 1197 + long free_mb = (long)(free_bytes / 1048576); 1198 + ac_log("[install] payload=%ldMB free=%ldMB on %s\n", 1199 + (long)((install_bytes + (1048576 - 1)) / 1048576), free_mb, devpath); 1200 + if (install_bytes > 0 && free_bytes < install_bytes + 10LL * 1048576LL) { 1115 1201 ac_log("[install] NOT ENOUGH SPACE — need %ldMB, have %ldMB\n", need_mb, free_mb); 1116 1202 // Repartition: expand ESP to 1024MB 1117 1203 char parent_blk[32] = ""; ··· 1259 1345 // Copy kernel (and initramfs/loader for systemd-boot layout) 1260 1346 long sz = 0; 1261 1347 if (systemd_boot_layout) { 1262 - // systemd-boot: copy bootloader, kernel, initramfs, and loader config 1263 - char src[256]; 1264 - 1265 - // Copy bootloader as BOOTX64.EFI 1266 - snprintf(src, sizeof(src), "%s/EFI/BOOT/BOOTX64.EFI", source_mount); 1267 - sz = copy_file(src, "/tmp/hd/EFI/BOOT/BOOTX64.EFI"); 1268 - ac_log("[install] bootloader: %ld bytes\n", sz); 1269 - 1270 - // Copy kernel 1271 - mkdir("/tmp/hd/EFI/Linux", 0755); 1272 - snprintf(src, sizeof(src), "%s/EFI/Linux/vmlinuz-ac-native", source_mount); 1273 - long ksz = copy_file(src, "/tmp/hd/EFI/Linux/vmlinuz-ac-native"); 1274 - ac_log("[install] kernel: %ld bytes\n", ksz); 1275 - 1276 - // Copy initramfs 1277 - snprintf(src, sizeof(src), "%s/initramfs.cpio.lz4", source_mount); 1278 - long isz = copy_file(src, "/tmp/hd/initramfs.cpio.lz4"); 1279 - ac_log("[install] initramfs: %ld bytes\n", isz); 1280 - 1281 - // Copy loader config 1348 + // Universal layout: splash BOOTX64.EFI + LOADER.EFI + 1349 + // KERNEL.EFI + initramfs + loader config. 1350 + long bsz = copy_file(bootloader_src, "/tmp/hd/EFI/BOOT/BOOTX64.EFI"); 1351 + long lsz = copy_file(loader_src, "/tmp/hd/EFI/BOOT/LOADER.EFI"); 1352 + long ksz = copy_file(chain_kernel_src, "/tmp/hd/EFI/BOOT/KERNEL.EFI"); 1353 + char initramfs_dst[128]; 1354 + const char *initramfs_name = strstr(initramfs_src, ".lz4") ? "initramfs.cpio.lz4" : "initramfs.cpio.gz"; 1355 + snprintf(initramfs_dst, sizeof(initramfs_dst), "/tmp/hd/%s", initramfs_name); 1356 + long isz = copy_file(initramfs_src, initramfs_dst); 1282 1357 mkdir("/tmp/hd/loader", 0755); 1283 1358 mkdir("/tmp/hd/loader/entries", 0755); 1284 - snprintf(src, sizeof(src), "%s/loader/loader.conf", source_mount); 1285 - copy_file(src, "/tmp/hd/loader/loader.conf"); 1286 - snprintf(src, sizeof(src), "%s/loader/entries/ac-native.conf", source_mount); 1287 - copy_file(src, "/tmp/hd/loader/entries/ac-native.conf"); 1288 - 1289 - sz = ksz > 0 ? ksz : sz; // use kernel size as success indicator 1359 + long csz = copy_file(loader_conf_src, "/tmp/hd/loader/loader.conf"); 1360 + long esz = copy_file(loader_entry_src, "/tmp/hd/loader/entries/ac-native.conf"); 1361 + ac_log("[install] bootloader: %ld bytes\n", bsz); 1362 + ac_log("[install] loader: %ld bytes\n", lsz); 1363 + ac_log("[install] kernel: %ld bytes\n", ksz); 1364 + ac_log("[install] initramfs: %ld bytes\n", isz); 1365 + ac_log("[install] loader.conf: %ld bytes\n", csz); 1366 + ac_log("[install] loader entry: %ld bytes\n", esz); 1367 + sz = (bsz > 0 && lsz > 0 && ksz > 0 && isz > 0 && csz > 0 && esz > 0) 1368 + ? (bsz + lsz + ksz + isz + csz + esz) 1369 + : -1; 1290 1370 } else if (chainloader_layout) { 1291 1371 long bsz = copy_file(bootloader_src, "/tmp/hd/EFI/BOOT/BOOTX64.EFI"); 1292 1372 long ksz = copy_file(chain_kernel_src, "/tmp/hd/EFI/BOOT/KERNEL.EFI"); 1293 1373 ac_log("[install] chainloader: %ld bytes\n", bsz); 1294 1374 ac_log("[install] kernel: %ld bytes\n", ksz); 1295 - sz = ksz > 0 ? ksz : bsz; 1375 + sz = (bsz > 0 && ksz > 0) ? (bsz + ksz) : -1; 1296 1376 } else { 1297 1377 // Monolithic: single BOOTX64.EFI is the kernel 1298 1378 sz = copy_file(kernel_src, "/tmp/hd/EFI/BOOT/BOOTX64.EFI"); ··· 1304 1384 snprintf(install_fail_reason, sizeof(install_fail_reason), 1305 1385 "copy failed on %s", devpath); 1306 1386 snprintf(install_fail_detail, sizeof(install_fail_detail), 1307 - "kernel copy returned %ld bytes", sz); 1387 + "install payload copy returned %ld bytes", sz); 1308 1388 umount("/tmp/hd"); 1309 1389 continue; 1310 1390 }