mirror of
https://gitlab.com/prism7/archery.git
synced 2026-04-28 17:37:36 +02:00
Jane Doe
4785 lines
185 KiB
Bash
4785 lines
185 KiB
Bash
#!/bin/bash
|
|
|
|
# Amelia installer for Archlinux
|
|
# Version: 1.4.0
|
|
# Source: https://gitlab.com/prism7/archery
|
|
|
|
set -euo pipefail
|
|
|
|
# TUI FUNCTIONS
|
|
vm() { inf "${yellowl}Virtual Machine ${nc}detected\n";}
|
|
ok() { sleep 0.2; NC "\n\n==> [${green}${prompt} OK${nc}]";}
|
|
NC() { echo -e "${nc} $1${nc}" ;}
|
|
y_n() { err "Please type 'y' or 'n' to continue.."; reload;}
|
|
RED() { echo -e "${red} $1${nc}" ;}
|
|
skip() { sleep 0.2; YELLOWL "\n\n --> Skipping..";}
|
|
BLUE() { echo -e "${blue} $1${nc}" ;}
|
|
CYAN() { echo -e "${cyan} $1${nc}" ;}
|
|
GREEN() { echo -e "${green} $1${nc}" ;}
|
|
REDBG() { echo -e "${redbg} $1${nc}" ;}
|
|
reload() { sleep 0.2; NC "\n\n --> [${green}Reloading${nc}]";}
|
|
choice() { err "Please make a choice to continue.."; reload;}
|
|
yes_no() { err "Please type 'yes' or 'no' to continue.."; reload;}
|
|
YELLOW() { echo -e "${yellow} $1${nc}" ;}
|
|
BLUEBG() { echo -e "${bluebg} $1${nc}" ;}
|
|
CYANBG() { echo -e "${cyanbg} $1${nc}" ;}
|
|
WHITEB() { echo -e "${bwhite} $1${nc}" ;}
|
|
invalid() { err "Invalid Response"; reload;}
|
|
err_try() { err "Errors occured. Please try again.."; reload;}
|
|
YELLOWL() { echo -e "${yellowl} $1${nc}" ;}
|
|
GREENBG() { echo -e "${greenbg} $1${nc}" ;}
|
|
MAGENTA() { echo -e "${magenta} $1${nc}" ;}
|
|
stage_ok() { sleep 0.2; GREEN "\n >> ${nc}${stage_prompt} ${green}OK"; sleep 0.3;}
|
|
keypress() { NC "\n\n\n ${bwhite}Press any key to continue\n\n"; read -r -s -n 1;}
|
|
err_abort() { err "Errors occured. Aborting.."; failure;}
|
|
do_umount() { unmount; reload;}
|
|
MAGENTABG() { echo -e "${magentabg} $1${nc}";}
|
|
umount_manual() { unmount; inf "Switching to ${yellowl}Manual Mode";}
|
|
err() {
|
|
local msg="$1"
|
|
local middle="${red}### ${nc}${msg}${red} ###${nc}"
|
|
local clean_middle
|
|
clean_middle="$(echo -e "$middle" | sed 's/\x1b\[[0-9;]*m//g')"
|
|
local visible_length="${#clean_middle}"
|
|
local dash_line
|
|
dash_line="$(printf '%*s' "$visible_length" '' | tr ' ' '-')"
|
|
local top_bottom="${red}${dash_line}${nc}"
|
|
sleep 0.2
|
|
printf "\n"
|
|
printf "%b\n" " $top_bottom"
|
|
printf "%b\n" " $middle"
|
|
printf "%b\n" " $top_bottom";}
|
|
msg() {
|
|
local msg="$1"
|
|
local middle="${green}### ${nc}${msg}${green} ###"
|
|
local clean_middle
|
|
clean_middle="$(echo -e "$middle" | sed 's/\x1b\[[0-9;]*m//g')"
|
|
local visible_length="${#clean_middle}"
|
|
local dash_line
|
|
dash_line="$(printf '%*s' "$visible_length" '' | tr ' ' '-')"
|
|
local top_bottom="${green}${dash_line}${nc}"
|
|
sleep 0.2
|
|
printf "\n"
|
|
printf "%b\n" " $top_bottom"
|
|
printf "%b\n" " $middle"
|
|
printf "%b\n" " $top_bottom"
|
|
}
|
|
inf() {
|
|
local msg="$1"
|
|
local string="${cyan}>> ${nc}${msg}${nc}"
|
|
sleep 0.2
|
|
printf "\n\n"
|
|
printf "%b\n" " $string"
|
|
}
|
|
ask() {
|
|
local msg="$1"
|
|
local string="${yellow}> ${msg}${yellow}:"
|
|
printf "\n\n"
|
|
printf "%b\n" " $string"
|
|
}
|
|
get() {
|
|
local msg="$1"
|
|
local string="${blue}${msg}${blue}:${nc}"
|
|
printf "\n\n"
|
|
printf "%b\n" "$string"
|
|
printf "\n"
|
|
}
|
|
ack() {
|
|
local msg="$1"
|
|
local string="${yellow}### ${msg}"
|
|
sleep 0.2
|
|
printf "\n\n"
|
|
printf "%b\n" " $string"
|
|
}
|
|
reboot() {
|
|
if [[ "${encrypt}" == "yes" ]]; then
|
|
if [[ "${luks_encrypt}" == "ok" ]]; then
|
|
inf "The system will now ${yellowl}reboot ${nc}for all changes to take effect\n\n"
|
|
sleep 3
|
|
systemctl reboot
|
|
else
|
|
inf "A reboot is ${yellowl}mandatory ${nc}after performing LUKS encryption\n\n"
|
|
sleep 3
|
|
systemctl reboot
|
|
fi
|
|
fi
|
|
}
|
|
title() {
|
|
local core="$*"
|
|
local left_sym="###"
|
|
local right_sym="###"
|
|
local bracket_open="[ "
|
|
local bracket_close=" ]"
|
|
local left_sym_len=${#left_sym}
|
|
local right_sym_len=${#right_sym}
|
|
local bracket_open_len=${#bracket_open}
|
|
local bracket_close_len=${#bracket_close}
|
|
local magenta_len=${#magenta}
|
|
local bwhite_len=${#bwhite}
|
|
local nc_len=${#nc}
|
|
local decor_len=$(( left_sym_len + right_sym_len + bracket_open_len + bracket_close_len + magenta_len + nc_len + bwhite_len * 2 ))
|
|
local total_len=126
|
|
local core_len=${#core}
|
|
local available=$(( total_len - decor_len - core_len ))
|
|
local half=$(( available / 2 ))
|
|
local core_padding=""
|
|
if (( available % 2 != 0 )); then
|
|
if [[ "$core" == *" "* ]]; then
|
|
local mid_index=$(( core_len / 2 ))
|
|
while [[ "${core:$mid_index:1}" != " " && $mid_index -gt 0 ]]; do
|
|
(( mid_index-- ))
|
|
done
|
|
core="${core:0:$mid_index} ${core:$mid_index}"
|
|
else
|
|
core_padding=" "
|
|
fi
|
|
fi
|
|
dashes_left=$(printf '%*s' "$half" '' | tr ' ' '-')
|
|
dashes_right=$(printf '%*s' "$half" '' | tr ' ' '-')
|
|
local core_adjusted="${magenta}${bracket_open}${bwhite}${core}${magenta}${bracket_close}${core_padding}"
|
|
local output="${magenta}${left_sym}${nc}${dashes_left}${core_adjusted}${nc}${dashes_right}${magenta}${right_sym}"
|
|
sleep 0.2
|
|
NC "\n\n\n$output\n"
|
|
}
|
|
unmount() {
|
|
inf "${yellowl}Unmount ${nc}and Retry"
|
|
reload
|
|
title "Unmount Filesystems"
|
|
if umount -R /mnt > "${void}" 2>&1 ; then
|
|
msg "Unmount OK"
|
|
else
|
|
err "Unmounting Failed"
|
|
failure
|
|
fi
|
|
}
|
|
stage_fail() {
|
|
sleep 0.2
|
|
RED "\n\n >> ${bwhite}${stage_prompt} ${nc}has ${red}FAILED${cyan}\n\n >> ${nc}Check ${yellowl}Amelia.log ${nc}for errors\n\n"
|
|
failure
|
|
}
|
|
completion_err() {
|
|
printf "\n\n"
|
|
if [[ -e /usr/bin/pv ]]; then
|
|
inf "Please complete ${yellowl}'${stage_prompt}' ${nc}to continue\n" | pv -qL 70
|
|
else
|
|
inf "Please complete ${yellowl}'${stage_prompt}' ${nc}to continue\n"
|
|
fi
|
|
}
|
|
amd() {
|
|
printf "\n\n"
|
|
sleep 0.2
|
|
REDBG " ------------------------------- "
|
|
REDBG " ### AMD Graphics detected ### "
|
|
REDBG " ------------------------------- "
|
|
NC "\n\n\n * ${gfxcard}\n\n"
|
|
}
|
|
intel() {
|
|
printf "\n\n"
|
|
sleep 0.2
|
|
BLUEBG " --------------------------------- "
|
|
BLUEBG " ### INTEL Graphics detected ### "
|
|
BLUEBG " --------------------------------- "
|
|
NC "\n\n\n * ${gfxcard}\n\n"
|
|
}
|
|
nvidia() {
|
|
printf "\n\n"
|
|
sleep 0.2
|
|
GREENBG " ---------------------------------- "
|
|
GREENBG " ### NVIDIA Graphics detected ### "
|
|
GREENBG " ---------------------------------- "
|
|
NC "\n\n\n * ${gfxcard}\n\n"
|
|
}
|
|
delete() {
|
|
sleep 0.2
|
|
printf "\n\n"
|
|
REDBG " ------------------------------------------------------------ "
|
|
REDBG " [!] WARNING: All data on selected disk will be destroyed [!] "
|
|
REDBG " ------------------------------------------------------------ "
|
|
}
|
|
amelia() {
|
|
sleep 0.2
|
|
CYANBG "************************************************************************************************* "
|
|
CYANBG " "
|
|
CYANBG " ### Amelia Installer ### "
|
|
CYANBG " "
|
|
CYANBG "************************************************************************************************* "
|
|
}
|
|
banner() {
|
|
sleep 0.2
|
|
echo
|
|
BLUEBG "************************************************************************************************* "
|
|
BLUEBG " "
|
|
BLUEBG " ### Archlinux Installation ### "
|
|
BLUEBG " "
|
|
BLUEBG "************************************************************************************************* "
|
|
printf "\n\n"
|
|
}
|
|
installing() {
|
|
sleep 0.2
|
|
printf "\n\n\n"
|
|
MAGENTABG "------------------------------------------------------------------------------------------------- "
|
|
MAGENTABG " ### Installing System ### "
|
|
MAGENTABG "------------------------------------------------------------------------------------------------- "
|
|
printf "\n"
|
|
}
|
|
cnfg() {
|
|
sleep 0.2
|
|
printf "\n\n\n"
|
|
MAGENTABG "------------------------------------------------------------------------------------------------- "
|
|
MAGENTABG " ### Configuring System ### "
|
|
MAGENTABG "------------------------------------------------------------------------------------------------- "
|
|
NC "\n\n\n ... Please Wait ...\n\n\n"
|
|
}
|
|
completion() {
|
|
sleep 0.2
|
|
printf "\n\n\n\n\n"
|
|
GREENBG "************************************************************************************************* "
|
|
GREENBG " "
|
|
GREENBG " ### Installation Completed ### "
|
|
GREENBG " "
|
|
GREENBG "************************************************************************************************* "
|
|
printf "\n\n\n"
|
|
}
|
|
failure() {
|
|
sleep 0.2
|
|
printf "\n\n\n"
|
|
REDBG "************************************************************************************************* "
|
|
REDBG " "
|
|
REDBG " ### Installation Aborted ### "
|
|
REDBG " "
|
|
REDBG "************************************************************************************************* "
|
|
printf "\n\n\n"
|
|
umount -R /mnt > "${void}" 2>&1
|
|
if [[ "${luks_root}" == "ok" || "${luks_swap}" == "ok" || "${luks_home}" == "ok" ]] && [[ "${installation}" != "ok" ]]; then
|
|
reboot
|
|
fi
|
|
exit
|
|
}
|
|
filesystem_overview() {
|
|
sleep 0.2
|
|
CYAN "\n\n###${nc}---------------------------------------------${cyan}[ ${bwhite}FILESYSTEM OVERVIEW ${nc}${cyan}]${nc}---------------------------------------------${cyan}###\n\n"
|
|
lsblk -f|GREP_COLORS='mt=01;36' grep -E --color=always 'vfat|$'|GREP_COLORS='mt=01;32' grep -E --color=always 'ext4|$'|GREP_COLORS='mt=01;35' grep -E --color=always 'btrfs|$'|GREP_COLORS='mt=01;31' grep -E --color=always 'ntfs|$'|GREP_COLORS='mt=01;33' grep -E --color=always 'swap|$'
|
|
CYAN "\n\n###${nc}-----------------------------------------------------------------------------------------------------------------${cyan}###\n"
|
|
sleep 0.2
|
|
}
|
|
disk_overview() {
|
|
sleep 0.2
|
|
CYAN "\n###${nc}------------------------------------------------${cyan}[ ${bwhite}DISK OVERVIEW ${nc}${cyan}]${nc}------------------------------------------------${cyan}###\n\n"
|
|
fdisk -l "${instl_drive}" | grep -E --color=no 'Dev|dev' |GREP_COLORS='mt=01;36' grep -E --color=always 'EFI System|$'|GREP_COLORS='mt=01;32' grep -E --color=always 'Linux root|$'|GREP_COLORS='mt=01;35' grep -E --color=always 'Linux home|$'|GREP_COLORS='mt=01;33' grep -E --color=always 'Linux swap|$'|GREP_COLORS='mt=01;31' grep -E --color=always 'Linux extended boot|$'
|
|
CYAN "\n\n###${nc}-----------------------------------------------------------------------------------------------------------------${cyan}###"
|
|
}
|
|
multi_info() {
|
|
sleep 0.2
|
|
CYAN "\n >> ${nc}Multiple ${color}${type} ${nc}Partitions have been detected\n\n"
|
|
disk_overview
|
|
NC "\n ${color}${type} Partitions:${nc}\n\n ${dashline}\n${multi_type}\n ${dashline}\n"
|
|
YELLOW "\n ### Only the ${nc}1st ${type} ${yellow}partition on a selected disk can be ${nc}auto-assigned ${yellow}as a valid partition${cyan}\n\n\n >> ${nc}Partition ${yellowl}${type_comply} ${nc}is auto-assigned as such and will be ${action}\n"
|
|
}
|
|
# END TUI FUNCTIONS
|
|
# SYSTEM FUNCTIONS
|
|
mode_check() {
|
|
if [[ "${run_as}" == "root" ]]; then
|
|
usermode="> ${nc}Running in ${red}ROOT ${nc}mode ${yellowl}<"
|
|
else
|
|
usermode="> ${nc}Running in ${blue}DEMO ${nc}mode ${yellowl}<"
|
|
fi
|
|
sleep 0.2
|
|
YELLOWL "\n\n\n\n ${usermode}\n\n\n\n\n\n"
|
|
}
|
|
check_fonts() {
|
|
if [[ -f /usr/share/kbd/consolefonts/ter-v18b.psf.gz && -f /usr/share/kbd/consolefonts/ter-v32b.psf.gz ]]; then
|
|
if [[ "${tty}" == *"tty"* && "${run_as}" == "root" ]]; then
|
|
until slct_font; do : ; done
|
|
else
|
|
if [[ -e /usr/bin/pv ]]; then
|
|
MAGENTABG " 'Terminus Font' detected ==> Log in as 'root' in a tty & re-run to enable " | pv -qL 70
|
|
else
|
|
MAGENTABG " 'Terminus Font' detected ==> Log in as 'root' in a tty & re-run to enable "
|
|
fi
|
|
echo
|
|
fi
|
|
fi
|
|
}
|
|
slct_font() {
|
|
local prompt="Font Selection"
|
|
title "${prompt}"
|
|
ask "Select a Font"
|
|
NC "\n\n [1] Terminus Font\n\n [2] HiDPI Terminus Font"
|
|
get "Enter a number"
|
|
read -r -p "==> " fontselect
|
|
case "${fontselect}" in
|
|
1)
|
|
setfont ter-v18b ;;
|
|
2)
|
|
setfont ter-v32b ;;
|
|
*)
|
|
invalid
|
|
return 1 ;;
|
|
esac
|
|
ok
|
|
sleep 0.5
|
|
clear
|
|
}
|
|
uefi_check() {
|
|
bitness="$(cat /sys/firmware/efi/fw_platform_size)"
|
|
local prompt="UEFI ${bitness}-bit Mode"
|
|
title "UEFI Mode Verification"
|
|
if [[ "${bitness}" == "64" ]]; then
|
|
uefimode="x86_64-efi"
|
|
efiname="BOOTX64"
|
|
ok
|
|
elif [[ "${bitness}" == "32" ]]; then
|
|
uefimode="i386-efi"
|
|
efiname="BOOTIA32"
|
|
ok
|
|
else
|
|
err "Not in UEFI Mode"
|
|
failure
|
|
fi
|
|
}
|
|
connection_check() {
|
|
local prompt="Internet Connection Check"
|
|
title "${prompt}"
|
|
if ping -c 3 www.google.com > "${void}" 2>&1; then
|
|
ok
|
|
else
|
|
printf "\n\n"
|
|
err "An internet connection could not be established"
|
|
printf "\n\n"
|
|
failure
|
|
fi
|
|
}
|
|
upd_clock() {
|
|
local prompt="System Clock Update"
|
|
title "${prompt}"
|
|
printf "\n\n"
|
|
sleep 0.2
|
|
timedatectl
|
|
[[ "${run_as}" == "root" ]] && timedatectl set-ntp true
|
|
ok
|
|
}
|
|
dtct_hyper() {
|
|
hypervisor="$(systemd-detect-virt)"
|
|
case "${hypervisor}" in
|
|
kvm)
|
|
vmpkgs="spice spice-vdagent spice-protocol spice-gtk qemu-guest-agent swtpm" ;;
|
|
vmware)
|
|
vmpkgs="open-vm-tools"
|
|
vm_services="vmtoolsd vmware-vmblock-fuse" ;;
|
|
oracle)
|
|
vmpkgs="virtualbox-guest-utils"
|
|
vm_services="vboxservice" ;;
|
|
microsoft)
|
|
vmpkgs="hyperv"
|
|
vm_services="hv_kvp_daemon hv_vss_daemon" ;;
|
|
esac
|
|
}
|
|
machine_dtct() {
|
|
until dtct_hyper; do : ; done
|
|
local prompt="Machine Detection"
|
|
title "${prompt}"
|
|
CPU="$(grep -E 'vendor_id' /proc/cpuinfo)"
|
|
hardw_model="$(hostnamectl | grep -E "Hardware Model:" | sed 's| Hardware Model: ||')"
|
|
hardw_model_vend="$(hostnamectl | grep -E "Hardware Model:" | sed 's| Hardware Model: ||' | awk "{print \$1}")"
|
|
hardw_vendor="$(hostnamectl | grep -E "Hardware Vendor" | awk "{print \$3}")"
|
|
machine="$(hostnamectl | grep -Em 1 "Chassis" | awk "{print \$2}")"
|
|
if [[ "${hypervisor}" != "none" ]]; then
|
|
vm
|
|
vendor="Virtual Machine"
|
|
fi
|
|
if [[ "${CPU}" == *"GenuineIntel"* ]]; then
|
|
microcode="intel-ucode"
|
|
nrg_plc="x86_energy_perf_policy"
|
|
cpu_name="Intel"
|
|
elif [[ "${CPU}" == *"AuthenticAMD"* ]]; then
|
|
microcode="amd-ucode"
|
|
cpu_name="AMD"
|
|
fi
|
|
if [[ "${hardw_model_vend}" == "${hardw_vendor}" ]]; then
|
|
inf "This system is a(n): ${yellowl}${hardw_model} ${bwhite}${machine}"
|
|
else
|
|
inf "This system is a(n): ${yellowl}${hardw_model} ${hardw_vendor} ${bwhite}${machine}"
|
|
fi
|
|
ack "The ${cpu_name} cpu microcode will be installed"
|
|
ok
|
|
}
|
|
main_menu() {
|
|
title "Main Menu"
|
|
ask "Make a selection"
|
|
if [[ -e /usr/bin/pv ]]; then
|
|
inf "Select ${bwhite}[4] ${nc}for ${yellowl}Auto-Navigation ${nc}Mode" | pv -qL 70
|
|
else
|
|
inf "Select ${bwhite}[4] ${nc}for ${yellowl}Auto-Navigation ${nc}Mode"
|
|
fi
|
|
NC "\n\n [1] Personalization\n\n [2] System Configuration\n\n [3] Disk Management\n\n [4] Start Installation"
|
|
get "Enter a number"
|
|
read -r -p "==> " menu
|
|
case "${menu}" in
|
|
1)
|
|
until persnl_submn; do : ; done ;;
|
|
2)
|
|
until sys_submn; do : ; done ;;
|
|
3)
|
|
until dsks_submn; do : ; done ;;
|
|
4)
|
|
instl ;;
|
|
"")
|
|
err "Please select a Submenu"
|
|
reload
|
|
return 1 ;;
|
|
*)
|
|
invalid
|
|
return 1 ;;
|
|
esac
|
|
}
|
|
persnl_submn() {
|
|
title "Personalization"
|
|
ask "Select a Submenu"
|
|
NC "\n\n [1] Locale & Keyboard Layout Setup\n\n [2] User, Root User & Hostname Setup\n\n [3] Shell Selection\n\n [ ] Return to Main Menu"
|
|
get "Enter a number"
|
|
read -r -p "==> " persmenu
|
|
case "${persmenu}" in
|
|
1)
|
|
until slct_locale; do : ; done
|
|
until slct_kbd; do : ; done
|
|
return 1 ;;
|
|
2)
|
|
until user_setup; do : ; done
|
|
until rootuser_setup; do : ; done
|
|
until slct_hostname; do : ; done
|
|
return 1 ;;
|
|
3)
|
|
until slct_shell; do : ; done
|
|
return 1 ;;
|
|
"")
|
|
until main_menu; do : ; done ;;
|
|
*)
|
|
invalid
|
|
return 1 ;;
|
|
esac
|
|
}
|
|
slct_locale() {
|
|
local prompt="Locale Selection"
|
|
title "${prompt}"
|
|
ask "Select your Locale"
|
|
ack "[Enter ${nc}'l'${yellow} to list locales, then ${nc}'enter'${yellow} to search or ${nc}'q'${yellow} to quit]"
|
|
inf "Exclude ${yellowl}'.UTF_8' ${nc}suffix"
|
|
get "Enter your Locale ${bwhite}(empty for 'en_US')"
|
|
read -r -p "==> " LOCALESET
|
|
if [[ -z "${LOCALESET}" ]]; then
|
|
SETLOCALE="en_US.UTF-8"
|
|
ack "en_US.UTF-8 Locale has been selected"
|
|
elif [[ "${LOCALESET}" == "l" ]]; then
|
|
grep -E 'UTF-8' /usr/share/i18n/SUPPORTED | less
|
|
return 1
|
|
elif ! grep -q "^#\?$(sed 's/[].*[]/\\&/g' <<< "${LOCALESET}") " /usr/share/i18n/SUPPORTED; then
|
|
invalid
|
|
return 1
|
|
else
|
|
SETLOCALE="${LOCALESET}.UTF-8"
|
|
ack "${SETLOCALE} Locale has been selected"
|
|
fi
|
|
ok
|
|
lcl_slct="yes"
|
|
}
|
|
slct_kbd() {
|
|
local prompt="Keyboard Layout Selection"
|
|
local stage_prompt="Setting Keyboard Layout"
|
|
title "${prompt}"
|
|
if [[ "${tty}" == *"pts"* ]]; then
|
|
SETKBD="us"
|
|
inf "No 'tty' ${yellowl}(Linux console) ${nc}detected"
|
|
ack "Default Keyboard Layout ('us') selected"
|
|
ok
|
|
return 0
|
|
fi
|
|
ask "Select your Keyboard Layout"
|
|
ack "[Enter ${nc}'l'${yellow} to list layouts, then ${nc}'enter'${yellow} to search or ${nc}'q'${yellow} to quit]"
|
|
get "Enter your keyboard layout ${bwhite}(empty for 'us')"
|
|
read -r -p "==> " SETKBD
|
|
if [[ -z "${SETKBD}" ]]; then
|
|
SETKBD="us"
|
|
ack "'us' Keyboard Layout has been selected"
|
|
elif [[ "${SETKBD}" == "l" ]]; then
|
|
localectl list-keymaps | less
|
|
return 1
|
|
elif ! localectl list-keymaps | grep -Fxq "${SETKBD}"; then
|
|
invalid
|
|
return 1
|
|
else
|
|
ack "${SETKBD} Keyboard Layout has been selected"
|
|
loadkeys "${SETKBD}" > "${void}" 2> "${log}" || stage_fail
|
|
fi
|
|
ok
|
|
}
|
|
user_setup() {
|
|
local prompt="User Setup"
|
|
title "${prompt}"
|
|
get "Enter a username"
|
|
read -r -p "==> " USERNAME
|
|
USERNAME="${USERNAME,,}"
|
|
if [[ -z "${USERNAME}" ]]; then
|
|
err "Please enter a username to continue"
|
|
reload
|
|
return 1
|
|
elif [[ "${USERNAME}" =~ ^[a-z_]([a-z0-9_-]{0,31}|[a-z0-9_-]{0,30}\$)$ ]]; then
|
|
get "Enter a password for${nc} ${cyan}${USERNAME}"
|
|
read -r -p "==> " USERPASSWD
|
|
if [[ -z "${USERPASSWD}" ]]; then
|
|
err "Please enter a password to continue"
|
|
reload
|
|
return 1
|
|
fi
|
|
get "Re-enter${nc} ${cyan}${USERNAME}'s ${blue}password"
|
|
read -r -p "==> " USERPASSWD2
|
|
if [[ "${USERPASSWD}" != "${USERPASSWD2}" ]]; then
|
|
err "Passwords don't match. Please try again.."
|
|
reload
|
|
return 1
|
|
fi
|
|
else
|
|
err "Please enter a valid username to continue"
|
|
reload
|
|
return 1
|
|
fi
|
|
ok
|
|
}
|
|
rootuser_setup() {
|
|
local prompt="Root User Setup"
|
|
title "${prompt}"
|
|
get "Enter a password for the${nc}${cyan} Root ${blue}user"
|
|
read -r -p "==> " ROOTPASSWD
|
|
if [[ -z "${ROOTPASSWD}" ]]; then
|
|
err "Please enter a password for the Root user to continue"
|
|
reload
|
|
return 1
|
|
fi
|
|
get "Re-enter${nc} ${cyan}Root ${blue}user's password"
|
|
read -r -p "==> " ROOTPASSWD2
|
|
if [[ "${ROOTPASSWD}" != "${ROOTPASSWD2}" ]]; then
|
|
err "Passwords don't match. Please try again.."
|
|
reload
|
|
return 1
|
|
fi
|
|
ok
|
|
}
|
|
slct_hostname() {
|
|
local prompt="Hostname Setup"
|
|
title "${prompt}"
|
|
get "Enter a hostname"
|
|
read -r -p "==> " HOSTNAME
|
|
if [[ -z "${HOSTNAME}" ]]; then
|
|
err "Please enter a hostname to continue"
|
|
reload
|
|
return 1
|
|
elif [[ "${HOSTNAME}" =~ [[:upper:]] ]]; then
|
|
err "Lowercase is preferred. Please try again.."
|
|
reload
|
|
return 1
|
|
fi
|
|
ok
|
|
}
|
|
slct_shell() {
|
|
local prompt="Shell Selection"
|
|
title "${prompt}"
|
|
ask "Select a Shell"
|
|
NC "\n\n [1] Bash\n\n [2] Zsh\n\n [3] Fish"
|
|
get "Enter a number"
|
|
read -r -p "==> " shellnmbr
|
|
case "${shellnmbr}" in
|
|
1)
|
|
shell=""
|
|
shellname="bash"
|
|
shellname2="Bash"
|
|
shell_pkgs="bash-completion powerline powerline-fonts" ;;
|
|
2)
|
|
shell="zsh"
|
|
shellname="zsh"
|
|
shellname2="Zsh"
|
|
shell_pkgs="powerline powerline-fonts zsh-autocomplete zsh-autosuggestions zsh-completions zsh-syntax-highlighting" ;;
|
|
3)
|
|
shell="fish"
|
|
shellname="fish"
|
|
shellname2="Fish"
|
|
shell_pkgs="powerline powerline-fonts which" ;;
|
|
"")
|
|
err "Please select a Shell"
|
|
reload
|
|
return 1 ;;
|
|
*)
|
|
invalid
|
|
return 1 ;;
|
|
esac
|
|
ack "The ${shellname2} shell has been selected"
|
|
ok
|
|
}
|
|
sys_submn() {
|
|
title "System Configuration"
|
|
ask "Select a Submenu"
|
|
NC "\n\n [1] Kernel, Secureboot Signing, Bootloader & ESP Mountpoint\n\n [2] Filesystem & Swap Setup\n\n [3] Graphics Setup\n\n [4] Desktop Setup\n\n [5] EFI Boot Entries Deletion\n\n [6] Extended Options\n\n [ ] Return to Main Menu"
|
|
get "Enter a number"
|
|
read -r -p "==> " sysmenu
|
|
case "${sysmenu}" in
|
|
1)
|
|
until slct_krnl; do : ; done
|
|
until ask_sign; do : ; done
|
|
until slct_bootldr; do : ; done
|
|
until slct_espmnt; do : ; done
|
|
return 1 ;;
|
|
2)
|
|
until slct_fs; do : ; done
|
|
until slct_swap; do : ; done
|
|
return 1 ;;
|
|
3)
|
|
until dtct_gfx; do : ; done
|
|
return 1 ;;
|
|
4)
|
|
until dsktp_setup; do : ; done
|
|
return 1 ;;
|
|
5)
|
|
until boot_entr; do : ; done
|
|
return 1 ;;
|
|
6)
|
|
until ext_opt_submn; do : ; done
|
|
return 1 ;;
|
|
"")
|
|
until main_menu; do : ; done ;;
|
|
*)
|
|
invalid
|
|
return 1 ;;
|
|
esac
|
|
}
|
|
slct_krnl() {
|
|
local prompt="Kernel Selection"
|
|
title "${prompt}"
|
|
ask "Select a Kernel"
|
|
NC "\n\n [1] Linux\n\n [2] Linux LTS\n\n [3] Linux Hardened\n\n [4] Linux Zen"
|
|
get "Enter a number"
|
|
read -r -p "==> " kernelnmbr
|
|
case "${kernelnmbr}" in
|
|
1)
|
|
kernel="linux"
|
|
kernelname="Linux" ;;
|
|
2)
|
|
kernel="linux-lts"
|
|
kernelname="Linux LTS" ;;
|
|
3)
|
|
inf "${yellowl}INFO: ${nc}System Hibernation is ${bwhite}not supported ${nc}by this kernel"
|
|
kernel="linux-hardened"
|
|
kernelname="Linux Hardened" ;;
|
|
4)
|
|
kernel="linux-zen"
|
|
kernelname="Linux Zen" ;;
|
|
"")
|
|
err "Please select a Kernel"
|
|
reload
|
|
return 1 ;;
|
|
*)
|
|
invalid
|
|
return 1 ;;
|
|
esac
|
|
ack "The ${kernelname} kernel has been selected"
|
|
ok
|
|
}
|
|
ask_sign() {
|
|
title "Secureboot Signing"
|
|
ask "Sign UKI(s), Kernel & binaries for use with Secure Boot ? [y/N]"
|
|
get "Enter [y/N]"
|
|
read -r -p "==> " sb_sign
|
|
sb_sign="${sb_sign:-n}"
|
|
sb_sign="${sb_sign,,}"
|
|
if [[ "${sb_sign}" == "y" ]]; then
|
|
local prompt="Secure Boot 'Setup' Mode Verification"
|
|
validpkgs+=(sbctl)
|
|
SB_Status="$(bootctl status 2> "${void}" | grep -E 'Secure Boot' | awk "{print \$4}")"
|
|
if [[ "${SB_Status}" == "(setup)" ]]; then
|
|
ok
|
|
else
|
|
err "Secure Boot Not in ${yellowl}'Setup' ${nc}Mode"
|
|
printf "\n\n"
|
|
failure
|
|
fi
|
|
ack "Secure Boot Signing' has been selected"
|
|
ask "Create an additional bootloader Rescue entry (for troubleshooting) ? [Y/n]"
|
|
get "Enter [Y/n]"
|
|
read -r -p "==> " setrescue
|
|
setrescue="${setrescue:-y}"
|
|
setrescue="${setrescue,,}"
|
|
if [[ "${setrescue}" == "y" ]]; then
|
|
local prompt="Rescue Entry set"
|
|
ok
|
|
elif [[ "${setrescue}" == "n" ]]; then
|
|
skip
|
|
else
|
|
y_n
|
|
return 1
|
|
fi
|
|
elif [[ "${sb_sign}" == "n" ]]; then
|
|
skip
|
|
else
|
|
y_n
|
|
return 1
|
|
fi
|
|
local prompt="Secure Boot Signing setup"
|
|
ok
|
|
}
|
|
slct_bootldr() {
|
|
local prompt="Bootloader Selection"
|
|
title "${prompt}"
|
|
ask "Select a Bootloader"
|
|
NC "\n\n [1] Systemd-boot\n\n [2] Grub"
|
|
get "Enter a number"
|
|
read -r -p "==> " bootloader
|
|
case "${bootloader}" in
|
|
1)
|
|
uki="y"
|
|
ukify="systemd-ukify"
|
|
ack "Systemd-boot has been selected" ;;
|
|
2)
|
|
uki="n"
|
|
ask "Select a Boot Path to install to"
|
|
NC "\n\n [1] Standard Path\n\n [2] Fallback Path -- for Removable Devices (recommended)"
|
|
get "Enter a number"
|
|
read -r -p "==> " path
|
|
case "${path}" in
|
|
1)
|
|
ack "Grub (Standard Boot Path) has been selected" ;;
|
|
2)
|
|
ack "Grub (Fallback Boot Path) has been selected" ;;
|
|
"")
|
|
err "Please select a Boot Path"
|
|
reload
|
|
return 1 ;;
|
|
*)
|
|
invalid
|
|
return 1 ;;
|
|
esac ;;
|
|
"")
|
|
err "Please select a Bootloader"
|
|
reload
|
|
return 1 ;;
|
|
*)
|
|
invalid
|
|
return 1 ;;
|
|
esac
|
|
ok
|
|
}
|
|
slct_espmnt() {
|
|
local prompt="ESP Mountpoint Selection"
|
|
title "${prompt}"
|
|
ask "Select a Mountpoint for the ESP"
|
|
NC "\n\n [1] /mnt/efi\n\n [2] /mnt/boot"
|
|
get "Enter a number"
|
|
read -r -p "==> " espmnt
|
|
case "${espmnt}" in
|
|
1)
|
|
esp_mount="/mnt/efi"
|
|
btldr_esp_mount="/efi"
|
|
ack "'/mnt/efi' mountpoint has been selected" ;;
|
|
2)
|
|
esp_mount="/mnt/boot"
|
|
btldr_esp_mount="/boot"
|
|
ack "'/mnt/boot' mountpoint has been selected" ;;
|
|
"")
|
|
err "Please select a Mountpoint"
|
|
reload
|
|
return 1 ;;
|
|
*)
|
|
invalid
|
|
return 1 ;;
|
|
esac
|
|
ok
|
|
if [[ "${sanity}" == "no" ]]; then
|
|
until sanity_check; do : ; done
|
|
fi
|
|
}
|
|
slct_fs() {
|
|
local prompt="Filesystem Selection"
|
|
title "${prompt}"
|
|
ask "Select Filesystem to be used"
|
|
NC "\n\n [1] Ext4\n\n [2] Btrfs"
|
|
get "Enter a number"
|
|
read -r -p "==> " fs
|
|
case "${fs}" in
|
|
1)
|
|
fsname="Ext4"
|
|
fs_mod="ext4"
|
|
fstools="e2fsprogs"
|
|
roottype="/Root"
|
|
inf "${yellowl}INFO: ${nc}Keeping User Data on a ${bwhite}separate ${nc}/Home partition is supported"
|
|
ask "Make use of a dedicated /Home partition ? [y/N]"
|
|
get "Enter [y/N]"
|
|
read -r -p "==> " sep_home
|
|
sep_home="${sep_home:-n}"
|
|
sep_home="${sep_home,,}"
|
|
case "${sep_home}" in
|
|
y)
|
|
ask "Make a selection"
|
|
NC "\n\n [1] Create a /Home partition\n\n [2] Utilize a previously used unencrypted /Home partition"
|
|
get "Enter a number"
|
|
read -r -p "==> " hometype
|
|
case "${hometype}" in
|
|
1)
|
|
ack "A /Home Partition will be created" ;;
|
|
2)
|
|
ack "An existing /Home Partition will be used" ;;
|
|
*)
|
|
invalid
|
|
return 1 ;;
|
|
esac ;;
|
|
n)
|
|
skip ;;
|
|
*)
|
|
invalid
|
|
return 1 ;;
|
|
esac
|
|
ack "${fsname} has been selected" ;;
|
|
2)
|
|
fsname="Btrfs"
|
|
fs_mod="btrfs"
|
|
fstools="btrfs-progs"
|
|
roottype="/@"
|
|
btrfs_bootopts="rootflags=subvol=@"
|
|
ack "${fsname} has been selected"
|
|
ask "Label your Btrfs snapshots directory"
|
|
get "Enter a name"
|
|
read -r -p "==> " snapname
|
|
if [[ -z "${snapname}" ]]; then
|
|
invalid
|
|
return 1
|
|
fi ;;
|
|
"")
|
|
err "Please select a Filesystem"
|
|
reload
|
|
return 1 ;;
|
|
*)
|
|
invalid
|
|
return 1 ;;
|
|
esac
|
|
ok
|
|
}
|
|
slct_swap() {
|
|
local prompt="Swap Selection"
|
|
title "${prompt}"
|
|
ask "Select Swap type"
|
|
NC "\n\n [1] Swap Partition\n\n [2] Swapfile\n\n [3] Zram Swap"
|
|
get "Enter a number ${bwhite}(empty to skip)"
|
|
read -r -p "==> " swapmode
|
|
case "${swapmode}" in
|
|
1)
|
|
swaptype="swappart"
|
|
ack "Swap Partition has been selected" ;;
|
|
2)
|
|
if [[ "${fs}" == "1" ]]; then
|
|
swaptype="swapfile"
|
|
elif [[ "${fs}" == "2" ]]; then
|
|
swaptype="swapfile_btrfs"
|
|
fi
|
|
ack "Swapfile has been selected"
|
|
until set_swapsize; do : ; done ;;
|
|
3)
|
|
inf "Hibernating to Swap on Zram is ${yellowl}not supported"
|
|
zram="zram-generator"
|
|
ack "Zram Swap has been selected" ;;
|
|
"")
|
|
ack "No Swap will be used"
|
|
skip ;;
|
|
*)
|
|
invalid
|
|
return 1 ;;
|
|
esac
|
|
ok
|
|
}
|
|
set_swapsize() {
|
|
local prompt="Swapsize"
|
|
inf "Set Swap ${yellowl}size ${nc}(integers only eg. 1,4,8,16,34)"
|
|
get "Enter Swap size ${bwhite}(in GB)"
|
|
read -r -p "==> " swapsize
|
|
if [[ -z "${swapsize}" ]]; then
|
|
err "Please enter a value to continue"
|
|
reload
|
|
return 1
|
|
elif [[ "${swapsize}" == [[:digit:]] ]]; then
|
|
ok
|
|
else
|
|
err "Please use only integers as a value"
|
|
reload
|
|
return 1
|
|
fi
|
|
}
|
|
dtct_gfx() {
|
|
gfx_slct="yes"
|
|
if [[ "${vendor}" == "Virtual Machine" ]]; then
|
|
vm
|
|
skip
|
|
return 0
|
|
fi
|
|
title "Graphics Setup"
|
|
gfxcount="$(lspci | grep -E -c 'VGA|Display|3D')"
|
|
gfxcard="$(lspci | grep -E 'VGA|Display|3D' | sed 's/^.*: //g')"
|
|
intelcount="$(lspci | grep -E 'VGA|Display|3D' | grep -E -c 'Intel Corporation')"
|
|
intelcards="$(lspci | grep -E 'VGA|Display|3D' | grep -E 'Intel Corporation'| sed 's/.*Corporation //g' | cat --number | sed 's/.[0-9]//')"
|
|
amdcount="$(lspci | grep -E 'VGA|Display|3D' | grep -E -c 'Advanced Micro Devices')"
|
|
amdcards="$(lspci | grep -E 'VGA|Display|3D' | grep -E 'Advanced Micro Devices' | sed 's/.*\[AMD\/ATI\] //g' | cat --number | sed 's/.[0-9]//')"
|
|
nvidiacount="$(lspci | grep -E 'VGA|Display|3D' | grep -E -c 'NVIDIA Corporation')"
|
|
nvidiacards="$(lspci | grep -E 'VGA|Display|3D' | grep -E 'NVIDIA Corporation'| sed 's/.*Corporation //g' | cat --number | sed 's/.[0-9]//')"
|
|
if [[ "${gfxcount}" == "1" ]]; then
|
|
dtct_single_gfx
|
|
else
|
|
dtct_multi_gfx
|
|
fi
|
|
}
|
|
dtct_single_gfx() {
|
|
if [[ "${intelcount}" -eq "1" ]]; then
|
|
vendor="Intel"
|
|
sourcetype="Open-source"
|
|
intel
|
|
elif [[ "${amdcount}" -eq "1" ]]; then
|
|
vendor="AMD"
|
|
sourcetype="Open-source"
|
|
amd
|
|
elif [[ "${nvidiacount}" -eq "1" ]]; then
|
|
vendor="Nvidia"
|
|
nvidia
|
|
sleep 0.2
|
|
CYAN "
|
|
### ${yellowl}Turing ${bwhite}(NV160/TUxxx) ${nc}Graphics or newer are officialy supported ${cyan}\n\n ### ${yellowl}Maxwell ${bwhite}(NV110/GMxxx) ${nc}through ${yellowl}Volta ${bwhite}(NV140/GVxxx) ${nc}Graphics are unofficialy supported ${yellowl}[AUR] ${nc}${cyan}\n\n\n ### ${nc}Selecting ${yellowl}(n)o ${nc}defaults to the ${bwhite}open-source ${yellowl}'nouveau' ${nc}driver"
|
|
ask "Install proprietary Nvidia drivers ? [Y/n]"
|
|
get "Enter [Y/n]"
|
|
read -r -p "==> " nvidiaprop
|
|
nvidiaprop="${nvidiaprop:-y}"
|
|
nvidiaprop="${nvidiaprop,,}"
|
|
if [[ "${nvidiaprop}" == "y" ]]; then
|
|
sourcetype="Proprietary"
|
|
elif [[ "${nvidiaprop}" == "n" ]]; then
|
|
sourcetype="Open-source"
|
|
skip
|
|
elif [[ ! "${nvidiaprop}" =~ ^(y|n)$ ]]; then
|
|
invalid
|
|
return 1
|
|
fi
|
|
fi
|
|
gfx_conf
|
|
}
|
|
dtct_multi_gfx() {
|
|
sleep 0.2
|
|
YELLOW "\n\n ### Multi Graphics Setup detected, consisting of:"
|
|
NC "\n ____________________________________________________________________"
|
|
if [[ "${intelcount}" -ge "1" ]]; then
|
|
echo
|
|
BLUEBG " ------------------------------- "
|
|
BLUEBG " [${intelcount}] Intel Graphics device(s) "
|
|
BLUEBG " ------------------------------- "
|
|
NC "\n${intelcards}\n\n ____________________________________________________________________"
|
|
fi
|
|
if [[ "${amdcount}" -ge "1" ]]; then
|
|
echo
|
|
REDBG " ------------------------------- "
|
|
REDBG " [${amdcount}] AMD Graphics device(s) "
|
|
REDBG " ------------------------------- "
|
|
NC "\n${amdcards}\n\n ____________________________________________________________________"
|
|
fi
|
|
if [[ "${nvidiacount}" -ge "1" ]]; then
|
|
echo
|
|
GREENBG " ------------------------------- "
|
|
GREENBG " [${nvidiacount}] Nvidia Graphics device(s) "
|
|
GREENBG " ------------------------------- "
|
|
NC "\n${nvidiacards}\n\n\n ${cyan}### ${yellowl}Turing ${bwhite}(NV160/TUxxx) ${nc}Graphics or newer are officialy supported ${cyan}\n\n ### ${yellowl}Maxwell ${bwhite}(NV110/GMxxx) ${nc}through ${yellowl}Volta ${bwhite}(NV140/GVxxx) ${nc}Graphics are unofficialy supported ${yellowl}[AUR] ${nc}${cyan}\n\n\n ### ${nc}Selecting ${yellowl}(n)o ${nc}defaults to the ${bwhite}open-source ${yellowl}'nouveau' ${nc}driver\n ________________________________________________________________"
|
|
ask "Install proprietary Nvidia drivers ? [Y/n]"
|
|
get "Enter [Y/n]"
|
|
read -r -p "==> " nvidiaprop
|
|
nvidiaprop="${nvidiaprop:-y}"
|
|
nvidiaprop="${nvidiaprop,,}"
|
|
if [[ "${nvidiaprop}" == "n" ]]; then
|
|
skip
|
|
elif [[ ! "${nvidiaprop}" =~ ^(y|n)$ ]]; then
|
|
invalid
|
|
return 1
|
|
fi
|
|
fi
|
|
multivendors=()
|
|
multisourcetype=()
|
|
if [[ "${intelcount}" -ge "1" ]]; then
|
|
multivendors+=(Intel)
|
|
multisourcetype+=(Open-source)
|
|
fi
|
|
if [[ "${amdcount}" -ge "1" ]]; then
|
|
multivendors+=(AMD)
|
|
multisourcetype+=(Open-source)
|
|
fi
|
|
if [[ "${nvidiacount}" -ge "1" ]]; then
|
|
multivendors+=(Nvidia)
|
|
if [[ "${nvidiaprop}" == "y" ]]; then
|
|
multisourcetype+=(Proprietary)
|
|
else
|
|
multisourcetype+=(Open-source)
|
|
fi
|
|
fi
|
|
vendors="${multivendors[*]}"
|
|
sourcetype="${multisourcetype[*]}"
|
|
if [[ "${sourcetype}" =~ "Open-source" && "${sourcetype}" =~ "Proprietary" ]]; then
|
|
sourcetype="Open-source & Proprietary"
|
|
elif [[ "${sourcetype}" =~ "Open-source" ]]; then
|
|
sourcetype="Open-source"
|
|
elif [[ "${sourcetype}" =~ "Proprietary" ]]; then
|
|
sourcetype="Proprietary"
|
|
fi
|
|
gfx_conf
|
|
}
|
|
gfx_conf() {
|
|
inf "${yellowl}${sourcetype} ${nc}drivers will be used"
|
|
if [[ "${vendor}" == "AMD" || "${vendors}" =~ "AMD" ]]; then
|
|
ask "Enable 'amdgpu' driver support for"
|
|
NC "\n\n [1] 'Southern Islands' Graphics\n\n [2] 'Sea Islands' Graphics"
|
|
get "Enter a number ${bwhite}(empty to skip)"
|
|
read -r -p "==> " islands
|
|
case "${islands}" in
|
|
1)
|
|
local prompt="Southern Islands"
|
|
ok ;;
|
|
2)
|
|
local prompt="Sea Islands"
|
|
ok ;;
|
|
"")
|
|
skip ;;
|
|
*)
|
|
invalid
|
|
return 1 ;;
|
|
esac
|
|
fi
|
|
if [[ "${nvidiaprop}" == "y" ]]; then
|
|
sleep 0.2
|
|
ask "Select Nvidia driver"
|
|
NC "\n\n [1] Nvidia-open ${yellowl}Turing ${bwhite}(NV160/TUxxx) ${nc}Graphics or newer\n\n [2] Nvidia-580xx-dkms [AUR] ${yellowl}Maxwell ${bwhite}(NV110/GMxxx) ${nc}through ${yellowl}Volta ${bwhite}(NV140/GVxxx) ${nc}Graphics"
|
|
get "Enter a number"
|
|
read -r -p "==> " family
|
|
case "${family}" in
|
|
1)
|
|
local prompt="Turing+"
|
|
ok ;;
|
|
2)
|
|
local prompt="Maxwell -> Volta"
|
|
ok
|
|
local prompt="GSP Firmware Disabled"
|
|
ask "Disable 'GSP' firmware ? [y/n]"
|
|
get "Enter [y/n]"
|
|
read -r -p "==> " nogsp
|
|
if [[ "${nogsp}" == "n" ]]; then
|
|
skip
|
|
elif [[ "${nogsp}" == "y" ]]; then
|
|
ok
|
|
else
|
|
y_n
|
|
return 1
|
|
fi ;;
|
|
"")
|
|
choice
|
|
return 1 ;;
|
|
*)
|
|
invalid
|
|
return 1 ;;
|
|
esac
|
|
local prompt="Low Latency Display Interrupts enabled"
|
|
ask "Enable Low Latency Display Interrupts (experimental) ? [Y/n]"
|
|
get "Enter [Y/n]"
|
|
read -r -p "==> " lowlat
|
|
lowlat="${lowlat:-y}"
|
|
lowlat="${lowlat,,}"
|
|
if [[ "${lowlat}" == "n" ]]; then
|
|
skip
|
|
elif [[ "${lowlat}" == "y" ]]; then
|
|
ok
|
|
else
|
|
y_n
|
|
return 1
|
|
fi
|
|
fi
|
|
ack "Graphics will be automatically configured"
|
|
local prompt="Graphics Setup"
|
|
ok
|
|
keypress
|
|
}
|
|
gfxpkgs_set() {
|
|
gfxpkgs=()
|
|
if [[ "${vendor}" == "Intel" || "${vendors}" =~ "Intel" ]]; then
|
|
perf_stream="dev.i915.perf_stream_paranoid = 0"
|
|
gfxpkgs+=(igsc intel-compute-runtime intel-media-driver intel-media-sdk libva-intel-driver libva-utils libvpl opencl-headers vpl-gpu-rt vkd3d vulkan-intel vulkan-mesa-layers)
|
|
fi
|
|
if [[ "${vendor}" == "AMD" || "${vendors}" =~ "AMD" ]]; then
|
|
gfxpkgs+=(libva-mesa-driver mesa-utils opencl-headers rocm-opencl-runtime vkd3d vulkan-mesa-layers vulkan-radeon)
|
|
fi
|
|
if [[ "${nvidiaprop}" == "y" ]]; then
|
|
if [[ "${swapmode}" =~ ^(1|2|3)$ ]]; then
|
|
sleep 0.2
|
|
NC "\n ----------------------------------------------------------------\n ${cyan}### ${yellowl}INFO: ${nc}When Hibernating ${cyan}###\n\n ### ${nc}Nvidia's ${yellowl}'Preserve-Video-Memory-After-Suspend' ${nc}feature ${cyan}###\n\n ### ${nc}is incompatible with ${yellowl}'Early KMS' ${nc}use ${cyan}###${nc}\n ----------------------------------------------------------------"
|
|
keypress
|
|
fi
|
|
gfxpkgs=(libva-mesa-driver libva-nvidia-driver libvdpau-va-gl vkd3d)
|
|
if [[ "${family}" == "1" ]]; then
|
|
gfxpkgs+=(nvidia-settings nvidia-utils opencl-nvidia opencl-headers)
|
|
if [[ "${kernelnmbr}" == "1" ]]; then
|
|
nvname="nvidia-open"
|
|
gfxpkgs+=(nvidia-open)
|
|
elif [[ "${kernelnmbr}" == "2" ]]; then
|
|
nvname="nvidia-open-lts"
|
|
gfxpkgs+=(nvidia-open-lts)
|
|
else
|
|
gfxpkgs+=(nvidia-open-dkms)
|
|
fi
|
|
elif [[ "${family}" == "2" ]]; then
|
|
nvidia_aur="y"
|
|
fi
|
|
elif [[ "${nvidiaprop}" == "n" ]]; then
|
|
gfxpkgs+=(libva-mesa-driver vulkan-nouveau)
|
|
fi
|
|
}
|
|
dsktp_setup() {
|
|
title "Desktop Setup"
|
|
ask "Make a selection"
|
|
NC "\n\n [1] Desktop Selection\n\n [2] Arch 'base-devel' Meta-package\n\n [3] Web browser Selection\n\n [4] Printer & Scanner Support\n\n [ ] Return to System Configuration"
|
|
get "Enter a number"
|
|
read -r -p "==> " desk_setup
|
|
case "${desk_setup}" in
|
|
1)
|
|
until dsktp_slct; do : ; done
|
|
return 1 ;;
|
|
2)
|
|
until base_devel; do : ; done
|
|
return 1 ;;
|
|
3)
|
|
until web_browser; do : ; done
|
|
return 1 ;;
|
|
4)
|
|
until print_scan; do : ; done
|
|
return 1 ;;
|
|
"")
|
|
until sys_submn; do : ; done ;;
|
|
*)
|
|
invalid
|
|
return 1 ;;
|
|
esac
|
|
}
|
|
term_offer() {
|
|
inf "${desktopname} desktop lacks a ${yellowl}native ${nc}terminal emulator by design"
|
|
ask "Install ${nc}'gnome-terminal' ${yellow}for convenience ? [Y/n]"
|
|
get "Enter [Y/n]"
|
|
read -r -p "==> " terminal
|
|
terminal="${terminal:-y}"
|
|
terminal="${terminal,,}"
|
|
case "${terminal}" in
|
|
y)
|
|
local prompt="Terminal"
|
|
ok ;;
|
|
n)
|
|
skip ;;
|
|
*)
|
|
invalid
|
|
until term_offer; do : ; done ;;
|
|
esac
|
|
}
|
|
alt_session_support() {
|
|
inf "${desktopname} desktop defaults to a(n) ${yellowl}${session} ${nc}session"
|
|
ask "Install ${nc}${alt_session} ${yellow}session support ? [N/y]"
|
|
get "Enter [N/y]"
|
|
read -r -p "==> " session_support
|
|
session_support="${session_support:-n}"
|
|
session_support="${session_support,,}"
|
|
case "${session_support}" in
|
|
y)
|
|
local prompt="${alt_session} support"
|
|
ok ;;
|
|
n)
|
|
skip ;;
|
|
*)
|
|
invalid
|
|
until alt_session_support; do : ; done ;;
|
|
esac
|
|
}
|
|
dsktp_slct() {
|
|
title "Desktop Selection"
|
|
deskpkgs=""
|
|
custompkgs=""
|
|
terminal=""
|
|
local prompt="Desktop Selection"
|
|
ask "Make a selection"
|
|
NC "\n\n [1] Plasma\n\n [2] Plasma Lite\n\n [3] Gnome\n\n [4] Gnome Lite\n\n [5] Xfce\n\n [6] Cinnamon\n\n [7] Deepin\n\n [8] Budgie\n\n [9] Lxqt\n\n [10] Mate\n\n [11] Basic Arch Linux (No GUI)\n\n [12] Custom Arch Linux\n\n [13] Cosmic\n\n [14] Pantheon"
|
|
get "Enter a number"
|
|
read -r -p "==> " desktop
|
|
case "${desktop}" in
|
|
1)
|
|
desktopname="Plasma"
|
|
ack "${desktopname} has been selected"
|
|
session="Wayland"
|
|
alt_session="X11"
|
|
alt_session_support
|
|
alt_session_pack="plasma-x11-session" ;;
|
|
2)
|
|
desktopname="Plasma Lite"
|
|
ack "${desktopname} has been selected"
|
|
session="Wayland"
|
|
alt_session="X11"
|
|
alt_session_support
|
|
alt_session_pack="plasma-x11-session" ;;
|
|
3)
|
|
desktopname="Gnome"
|
|
ack "${desktopname} has been selected" ;;
|
|
4)
|
|
desktopname="Gnome Lite"
|
|
ack "${desktopname} has been selected" ;;
|
|
5)
|
|
desktopname="Xfce"
|
|
ack "${desktopname} has been selected"
|
|
session="X11"
|
|
alt_session="Wayland (experimental)"
|
|
alt_session_support
|
|
alt_session_pack="labwc";;
|
|
6)
|
|
desktopname="Cinnamon"
|
|
ack "${desktopname} has been selected"
|
|
term_offer ;;
|
|
7)
|
|
desktopname="Deepin"
|
|
ack "${desktopname} has been selected" ;;
|
|
8)
|
|
desktopname="Budgie"
|
|
ack "${desktopname} has been selected"
|
|
term_offer ;;
|
|
9)
|
|
desktopname="Lxqt"
|
|
ack "${desktopname} has been selected"
|
|
session="X11"
|
|
alt_session="Wayland (experimental)"
|
|
alt_session_support
|
|
alt_session_pack="labwc lxqt-wayland-session waylock" ;;
|
|
10)
|
|
desktopname="Mate"
|
|
ack "${desktopname} has been selected" ;;
|
|
11)
|
|
desktopname="Basic Arch Linux"
|
|
ack "${desktopname} has been selected" ;;
|
|
12)
|
|
desktopname="Custom Arch Linux"
|
|
until cust_sys; do :; done
|
|
return 0 ;;
|
|
13)
|
|
desktopname="Cosmic"
|
|
ack "${desktopname} has been selected" ;;
|
|
14)
|
|
desktopname="Pantheon"
|
|
ack "${desktopname} has been selected" ;;
|
|
"")
|
|
choice
|
|
keypress
|
|
return 1 ;;
|
|
*)
|
|
invalid
|
|
keypress
|
|
return 1 ;;
|
|
esac
|
|
ok
|
|
if [[ -n "${web}" && "${desktop}" =~ ^(11|12)$ ]]; then
|
|
until web_browser; do : ; done
|
|
fi
|
|
if [[ "${printer}" == "y" && "${desktop}" =~ ^(11|12)$ ]]; then
|
|
until print_scan; do : ; done
|
|
fi
|
|
}
|
|
cust_sys() {
|
|
local prompt="Custom Arch Linux"
|
|
until add_pkgs; do : ; done
|
|
until add_services; do : ; done
|
|
ok
|
|
}
|
|
add_pkgs() {
|
|
local prompt="Adding Packages"
|
|
title "Add Your Packages"
|
|
inf "${bwhite}'base'${nc}, ${bwhite}'linux-firmware' ${nc}(if on bare-metal), ${bwhite}'sudo' ${nc}& your ${bwhite}current ${nc}choices are already ${yellowl}included${nc}\n"
|
|
get "Enter any additional packages ${bwhite}(space-seperated)"
|
|
read -r -p "==> " custompkgs
|
|
if [[ -z "${custompkgs}" ]]; then
|
|
err "Please enter package(s) to continue"
|
|
reload
|
|
return 1
|
|
else
|
|
ok
|
|
fi
|
|
}
|
|
add_services() {
|
|
local prompt="Adding Services"
|
|
title "Add Your Services"
|
|
ack "Empty to skip"
|
|
get "Enter services to be enabled ${bwhite}(space-seperated)"
|
|
read -r -p "==> " customservices
|
|
if [[ -z "${customservices}" ]]; then
|
|
skip
|
|
else
|
|
ok
|
|
fi
|
|
}
|
|
base_devel() {
|
|
local prompt="'base-devel' Meta-Package"
|
|
title "${prompt}"
|
|
inf "${yellowl}INFO: ${nc}The ${bwhite}'base' ${nc}meta-package does not include the ${bwhite}tools ${nc}needed for building packages"
|
|
ask "Install 'base-devel' meta-package ? [y/N]"
|
|
get "Enter [y/N]"
|
|
read -r -p "==> " dev
|
|
dev="${dev:-n}"
|
|
dev="${dev,,}"
|
|
case "${dev}" in
|
|
y)
|
|
devel="base-devel"
|
|
validpkgs+=(base-devel)
|
|
ack "The 'base-devel' meta-package will be installed" ;;
|
|
n)
|
|
skip ;;
|
|
*)
|
|
invalid
|
|
return 1 ;;
|
|
esac
|
|
ok
|
|
}
|
|
web_browser() {
|
|
title "Web Browser Selection"
|
|
if [[ ! "${desktop}" =~ ^(11|12)$ && -n "${desktop}" ]]; then
|
|
local prompt="Web Browser"
|
|
ask "Select Web Browser to install"
|
|
NC "\n\n [1] Firefox\n\n [2] Chromium\n\n [3] Vivaldi\n\n [4] Brave Browser\n\n [5] Microsoft Edge\n\n [6] Zen Browser\n\n [7] Opera\n\n [8] Google Chrome\n\n [9] Helium Browser"
|
|
get "Enter a number ${bwhite}(empty to skip)"
|
|
read -r -p "==> " web
|
|
case "${web}" in
|
|
1)
|
|
web_pkg="firefox"
|
|
web_name="Firefox" ;;
|
|
2)
|
|
web_pkg="chromium"
|
|
web_name="Chromium" ;;
|
|
3)
|
|
web_pkg="vivaldi"
|
|
web_name="Vivaldi" ;;
|
|
4)
|
|
web_aur="brave-bin"
|
|
web_aur_url="https://aur.archlinux.org/cgit/aur.git/snapshot/brave-bin.tar.gz"
|
|
web_name="Brave Browser" ;;
|
|
5)
|
|
web_aur="microsoft-edge-stable-bin"
|
|
web_aur_url="https://aur.archlinux.org/cgit/aur.git/snapshot/microsoft-edge-stable-bin.tar.gz"
|
|
web_name="Microsoft Edge" ;;
|
|
6)
|
|
web_aur="zen-browser-bin"
|
|
web_aur_url="https://aur.archlinux.org/cgit/aur.git/snapshot/zen-browser-bin.tar.gz"
|
|
web_name="Zen Browser" ;;
|
|
7)
|
|
web_aur="opera"
|
|
web_aur_url="https://aur.archlinux.org/cgit/aur.git/snapshot/opera.tar.gz"
|
|
web_name="Opera" ;;
|
|
8)
|
|
web_aur="google-chrome"
|
|
web_aur_url="https://aur.archlinux.org/cgit/aur.git/snapshot/google-chrome.tar.gz"
|
|
web_name="Google Chrome" ;;
|
|
9)
|
|
web_aur="helium-browser-bin"
|
|
web_aur_url="https://aur.archlinux.org/cgit/aur.git/snapshot/helium-browser-bin.tar.gz"
|
|
web_name="Helium Browser" ;;
|
|
"")
|
|
web_pkg=""
|
|
web_aur=""
|
|
web_aur_url=""
|
|
web_name=""
|
|
web_slct="yes"
|
|
skip
|
|
ok ;;
|
|
*)
|
|
invalid
|
|
return 1 ;;
|
|
esac
|
|
if [[ "${web}" =~ ^(4|5|6|7|8|9)$ && -z "${devel}" ]]; then
|
|
validpkgs+=(base-devel)
|
|
fi
|
|
else
|
|
echo
|
|
err "Incompatible selection detected"
|
|
inf "${yellowl}Basic ${nc}Arch Linux / ${yellowl}Custom ${nc}Arch Linux detected or ${yellowl}No Desktop ${nc}selected yet"
|
|
ack "No Browser selected"
|
|
web_pkg=""
|
|
web_aur=""
|
|
web_name=""
|
|
web_slct=""
|
|
skip
|
|
keypress
|
|
fi
|
|
if [[ "${web}" =~ ^(1|2|3|4|5|6|7|8|9)$ ]]; then
|
|
local prompt="${web_name}"
|
|
web_slct="yes"
|
|
ok
|
|
fi
|
|
}
|
|
print_scan() {
|
|
local prompt="Printer & Scanner Support"
|
|
title "${prompt}"
|
|
if [[ "${vendor}" != "Virtual Machine" ]]; then
|
|
if [[ ! "${desktop}" =~ ^(11|12)$ && -n "${desktop}" ]]; then
|
|
ask "Enable Printer & Scanner support ? [y/N]"
|
|
get "Enter [y/N]"
|
|
read -r -p "==> " printer
|
|
printer="${printer:-n}"
|
|
printer="${printer,,}"
|
|
case "${printer}" in
|
|
y)
|
|
collect_print_pkgs=(bluez-cups cups-pdf cups-browsed cups-pk-helper foomatic-db-gutenprint-ppds gutenprint ipp-usb libusb nss-mdns sane-airscan system-config-printer xdg-utils colord)
|
|
if [[ "${desktop}" == "2" ]]; then
|
|
collect_print_pkgs+=(print-manager skanlite)
|
|
elif [[ "${desktop}" == "4" ]]; then
|
|
collect_print_pkgs+=(simple-scan)
|
|
fi
|
|
print_pkgs="${collect_print_pkgs[*]}" ;;
|
|
n)
|
|
print_pkgs=""
|
|
skip ;;
|
|
*)
|
|
invalid
|
|
return 1 ;;
|
|
esac
|
|
ok
|
|
else
|
|
echo
|
|
err "Incompatible selection detected"
|
|
inf "${yellowl}Basic ${nc}Arch Linux / ${yellowl}Custom ${nc}Arch Linux detected or ${yellowl}No Desktop ${nc}selected yet"
|
|
ack "Printer/Scanner support not enabled"
|
|
print_pkgs=""
|
|
skip
|
|
ok
|
|
keypress
|
|
fi
|
|
else
|
|
print_pkgs=""
|
|
vm
|
|
skip
|
|
ok
|
|
fi
|
|
}
|
|
boot_entr() {
|
|
if [[ "${vendor}" == "Virtual Machine" ]]; then
|
|
efi_entr_del="yes"
|
|
vm
|
|
skip
|
|
return 0
|
|
fi
|
|
local prompt="Boot Entries"
|
|
title "EFI Boot Entries Deletion"
|
|
ask "Select an EFI Boot Entry to Delete ${red}[!] (CAUTION) [!]${nc} "
|
|
printf "\n\n\n"
|
|
NC ""
|
|
efibootmgr --unicode
|
|
entrnmbr="$(efibootmgr --unicode | grep -E 'BootOrder' | awk "{print \$2}")"
|
|
boot_entry=" "
|
|
while [[ -n "${boot_entry}" ]]; do
|
|
get "Enter a Boot Entry number for Deletion ${bwhite}(empty to skip)"
|
|
CYAN "\nBoot Entries: ${yellowl}${entrnmbr}\n"
|
|
read -r -p "==> " boot_entry
|
|
if [[ -n "${boot_entry}" ]]; then
|
|
if [[ "${run_as}" != "root" ]]; then
|
|
err "Root Privileges Missing.."
|
|
reload
|
|
until sys_submn; do : ; done
|
|
fi
|
|
if efibootmgr -b "${boot_entry}" -B --unicode; then
|
|
local prompt="Entry ${boot_entry} Deleted"
|
|
ok
|
|
else
|
|
err_try
|
|
return 1
|
|
fi
|
|
else
|
|
skip
|
|
ok
|
|
fi
|
|
done
|
|
efi_entr_del="yes"
|
|
}
|
|
ext_opt_submn() {
|
|
title "Extended Options"
|
|
ask "Make a selection"
|
|
NC "\n\n [1] Custom Kernel Parameters\n\n [2] System Watchdogs\n\n [3] General System Optimizations\n\n [4] Wireless Regulatory Domain\n\n [5] Systemd-oomd\n\n [6] Irqbalance\n\n [7] Thermald\n\n [8] Rng-tools\n\n [9] Rtkit\n\n [10] Tlp\n\n [ ] Return to System Configuration"
|
|
get "Enter a number"
|
|
read -r -p "==> " set_ext_opt
|
|
case "${set_ext_opt}" in
|
|
1)
|
|
until cust_kern_param; do : ; done
|
|
return 1 ;;
|
|
2)
|
|
until sys_watchdog; do : ; done
|
|
return 1 ;;
|
|
3)
|
|
until sysoptm; do : ; done
|
|
return 1 ;;
|
|
4)
|
|
until ask_wireless_regdom; do : ; done
|
|
return 1 ;;
|
|
5)
|
|
until systemd_oomd; do : ; done
|
|
return 1 ;;
|
|
6)
|
|
until irqbalance; do : ; done
|
|
return 1 ;;
|
|
7)
|
|
until thermald; do : ; done
|
|
return 1 ;;
|
|
8)
|
|
until rngd; do : ; done
|
|
return 1 ;;
|
|
9)
|
|
until rtkit; do : ; done
|
|
return 1 ;;
|
|
10)
|
|
until tlp; do : ; done
|
|
return 1 ;;
|
|
"")
|
|
until sys_submn; do : ; done ;;
|
|
*)
|
|
invalid
|
|
return 1 ;;
|
|
esac
|
|
}
|
|
display_ext_opt() {
|
|
local prompt="Extended Options"
|
|
ask "Display Extended Options ? [y/N]"
|
|
get "Enter [y/N]"
|
|
read -r -p "==> " show_extopts
|
|
show_extopts="${show_extopts:-n}"
|
|
show_extopts="${show_extopts,,}"
|
|
if [[ "${show_extopts}" == "n" ]]; then
|
|
skip
|
|
ok
|
|
elif [[ "${show_extopts}" == "y" ]]; then
|
|
return 0
|
|
else
|
|
invalid
|
|
return 1
|
|
fi
|
|
}
|
|
cust_kern_param() {
|
|
local prompt="Custom Kernel Parameters"
|
|
title "${prompt}"
|
|
inf "${yellowl}Custom ${nc}Kernel parameters can be set at ${bwhite}boot ${nc}time"
|
|
ask "Enter your own additional Kernel parameters to be added to the Kernel cmdline ? [y/N]"
|
|
get "Enter [y/N]"
|
|
read -r -p "==> " ask_param
|
|
ask_param="${ask_param:-n}"
|
|
ask_param="${ask_param,,}"
|
|
case "${ask_param}" in
|
|
y)
|
|
until add_prmtrs; do : ; done ;;
|
|
n)
|
|
skip
|
|
ok ;;
|
|
*)
|
|
invalid
|
|
return 1 ;;
|
|
esac
|
|
}
|
|
add_prmtrs() {
|
|
local prompt="Custom Kernel Parameters"
|
|
ask "Add Your Kernel parameters ${nc}(Empty to skip)"
|
|
get "Enter your own Kernel parameters to be set at boot ${bwhite}(space-seperated)"
|
|
read -r -p "==> " cust_bootopts
|
|
if [[ -z "${cust_bootopts}" ]]; then
|
|
skip
|
|
ok
|
|
else
|
|
ok
|
|
fi
|
|
}
|
|
sys_watchdog() {
|
|
local prompt="System Watchdogs"
|
|
title "${prompt}"
|
|
CYAN "\n\n ### ${nc}A watchdog is a hardware or software component that keeps track of a system's performance${cyan}\n\n ### ${nc}and intervenes if it notices any strange behaviour or malfunctions"
|
|
ask "Disable Watchdogs in the installed system ? [y/N]"
|
|
get "Enter [y/N]"
|
|
read -r -p "==> " kill_watchdog
|
|
kill_watchdog="${kill_watchdog:-n}"
|
|
kill_watchdog="${kill_watchdog,,}"
|
|
case "${kill_watchdog}" in
|
|
y)
|
|
ack "Watchdogs will be disabled" ;;
|
|
n)
|
|
skip ;;
|
|
*)
|
|
invalid
|
|
return 1 ;;
|
|
esac
|
|
ok
|
|
}
|
|
sysoptm() {
|
|
local prompt="System Optimizations"
|
|
title "${prompt}"
|
|
CYAN "\n\n ### ${nc}System Optimizations are available${cyan}\n\n ### ${nc}Type ${yellowl}'v' ${nc}to view a summary"
|
|
ask "Enable System Optimizations ? [v/y/N]"
|
|
get "Enter [v/y/N]"
|
|
read -r -p "==> " sys_optm
|
|
sys_optm="${sys_optm:-n}"
|
|
sys_optm="${sys_optm,,}"
|
|
case "${sys_optm}" in
|
|
y)
|
|
validpkgs+=("ccache" "ntfs-3g" "pbzip2" "pigz")
|
|
ack "System Optimizations will be set" ;;
|
|
n)
|
|
skip ;;
|
|
v)
|
|
view_optm
|
|
return 1 ;;
|
|
*)
|
|
invalid
|
|
return 1 ;;
|
|
esac
|
|
ok
|
|
}
|
|
ask_wireless_regdom() {
|
|
if [[ "${vendor}" == "Virtual Machine" ]]; then
|
|
vm
|
|
skip
|
|
return 0
|
|
fi
|
|
local prompt="Wireless Regdom Setup"
|
|
title "Wireless Regulatory Domain Setup"
|
|
CYAN "\n\n ### ${nc}The regulatory domain is used to reconfigure wireless drivers, to make sure that wireless${cyan}\n\n ### ${nc}hardware usage complies with local laws set by the FCC, ETSI and other organizations"
|
|
ask "Select your Country Code (e.g. US)"
|
|
ack "[Enter ${nc}'l'${yellow} to list country codes, then ${nc}'enter'${yellow} to search or ${nc}'q'${yellow} to quit]"
|
|
get "Enter your Country Code ${bwhite}(empty to skip)"
|
|
read -r -p "==> " REGDOM
|
|
REGDOM="${REGDOM^^}"
|
|
if [[ -z "${REGDOM}" ]]; then
|
|
skip
|
|
elif [[ "${REGDOM}" == "L" ]]; then
|
|
sed 's|^#WIRELESS_REGDOM=||g' /etc/conf.d/wireless-regdom | sed 's|"||g'| less
|
|
return 1
|
|
elif ! grep \""${REGDOM}"\" /etc/conf.d/wireless-regdom > "${void}" 2>&1 ; then
|
|
invalid
|
|
return 1
|
|
else
|
|
wireless_reg="wireless-regdb"
|
|
ack "${REGDOM} Country Code has been selected"
|
|
fi
|
|
ok
|
|
}
|
|
systemd_oomd() {
|
|
local prompt="Systemd-oomd Setup"
|
|
title "${prompt}"
|
|
CYAN "\n\n ### ${nc}A system service that uses cgroups-v2 and pressure stall information (PSI)\n\n${cyan} ### ${nc}to monitor system and take corrective action before an 'OOM' occurs in the kernel space"
|
|
ask "Enable 'systemd-oomd' ? [y/N]"
|
|
inf "Swapping enabled is ${yellowl}highly recommended ${nc}for optimal performance"
|
|
get "Enter [y/N]"
|
|
read -r -p "==> " oomd
|
|
oomd="${oomd:-n}"
|
|
oomd="${oomd,,}"
|
|
if [[ "${oomd}" == "y" ]]; then
|
|
ack "'Systemd-oomd' service will be enabled"
|
|
elif [[ "${oomd}" == "n" ]]; then
|
|
skip
|
|
else
|
|
invalid
|
|
return 1
|
|
fi
|
|
ok
|
|
}
|
|
irqbalance() {
|
|
local prompt="Irqbalance Setup"
|
|
title "${prompt}"
|
|
CYAN "\n\n ### ${nc}Distributes hardware interrupts across processors on a multiprocessor system${cyan}\n\n ### ${nc}in order to increase performance"
|
|
ask "Install & enable 'irqbalance' ? [y/N]"
|
|
get "Enter [y/N]"
|
|
read -r -p "==> " irqbalance
|
|
irqbalance="${irqbalance:-n}"
|
|
irqbalance="${irqbalance,,}"
|
|
if [[ "${irqbalance}" == "y" ]]; then
|
|
validpkgs+=(irqbalance)
|
|
ack "'irqbalance' service will be enabled"
|
|
elif [[ "${irqbalance}" == "n" ]]; then
|
|
skip
|
|
else
|
|
invalid
|
|
return 1
|
|
fi
|
|
ok
|
|
}
|
|
thermald() {
|
|
local prompt="Thermald Setup"
|
|
title "${prompt}"
|
|
CYAN "\n\n ### ${nc}A Linux daemon used to prevent the overheating of ${yellowl}Intel ${nc}platforms\n\n${cyan} ### ${nc}This daemon monitors temperature and applies compensation using available cooling methods"
|
|
ask "Install & enable 'thermald' ? [y/N]"
|
|
get "Enter [y/N]: "
|
|
read -r -p "==> " thermald
|
|
thermald="${thermald:-n}"
|
|
thermald="${thermald,,}"
|
|
if [[ "${thermald}" == "y" ]]; then
|
|
validpkgs+=(thermald)
|
|
ack "'thermald' service will be enabled"
|
|
elif [[ "${thermald}" == "n" ]]; then
|
|
skip
|
|
else
|
|
invalid
|
|
return 1
|
|
fi
|
|
ok
|
|
}
|
|
rngd() {
|
|
local prompt="Rng-tools Setup"
|
|
title "${prompt}"
|
|
CYAN "\n\n ### ${nc}The rngd daemon is capable of using both environmental noise\n\n${cyan} ### ${nc}and hardware random number generators for extracting entropy"
|
|
ask "Install & enable 'rngd' ? [y/N] "
|
|
get "Enter [y/N]"
|
|
read -r -p "==> " rngd
|
|
rngd="${rngd:-n}"
|
|
rngd="${rngd,,}"
|
|
if [[ "${rngd}" == "y" ]]; then
|
|
validpkgs+=(rng-tools)
|
|
ack "'rngd' service will be enabled"
|
|
elif [[ "${rngd}" == "n" ]]; then
|
|
skip
|
|
else
|
|
invalid
|
|
return 1
|
|
fi
|
|
ok
|
|
}
|
|
rtkit() {
|
|
local prompt="Rtkit Setup"
|
|
title "${prompt}"
|
|
CYAN "\n\n ### ${nc}RealtimeKit is a D-Bus system service that changes the scheduling policy\n\n${cyan} ### ${nc}of user processes/threads to SCHED_RR, [Realtime Scheduling Mode on request]"
|
|
ask "Install & enable 'rtkit' ? [y/N]"
|
|
get "Enter [y/N]"
|
|
read -r -p "
|
|
==> " rtkit
|
|
rtkit="${rtkit:-n}"
|
|
rtkit="${rtkit,,}"
|
|
if [[ "${rtkit}" == "y" ]]; then
|
|
validpkgs+=("realtime-privileges" "rtkit")
|
|
ack "'rtkit' service will be enabled"
|
|
elif [[ "${rtkit}" == "n" ]]; then
|
|
skip
|
|
else
|
|
invalid
|
|
return 1
|
|
fi
|
|
ok
|
|
}
|
|
tlp() {
|
|
local prompt="Tlp Setup"
|
|
title "${prompt}"
|
|
CYAN "\n\n ### ${nc}Tlp is a laptop battery power saving utility for Linux\n\n${cyan} ### ${nc}working out-of-the-box & easy to further configure"
|
|
ask "Install & enable 'tlp' ? [y/N]"
|
|
get "Enter [y/N]"
|
|
read -r -p "==> " tlp
|
|
tlp="${tlp:-n}"
|
|
tlp="${tlp,,}"
|
|
if [[ "${tlp}" == "y" ]]; then
|
|
validpkgs+=(tlp)
|
|
ack "'tlp' service will be enabled"
|
|
elif [[ "${tlp}" == "n" ]]; then
|
|
skip
|
|
else
|
|
invalid
|
|
return 1
|
|
fi
|
|
ok
|
|
}
|
|
dsks_submn() {
|
|
title "Disk Management"
|
|
ask "Select a Submenu"
|
|
NC "\n\n [1] GPT Manager\n\n [2] Partition Manager\n\n [ ] Return to Main Menu"
|
|
get "Enter a number"
|
|
read -r -p "==> " diskmenu
|
|
case "${diskmenu}" in
|
|
1)
|
|
until gpt_mngr; do : ; done ;;
|
|
2)
|
|
until part_mngr; do : ; done ;;
|
|
"")
|
|
until main_menu; do : ; done ;;
|
|
*)
|
|
invalid
|
|
return 1 ;;
|
|
esac
|
|
}
|
|
gpt_mngr() {
|
|
local prompt="GPT Manager"
|
|
title "${prompt}"
|
|
gpt_dsk_nmbr=" "
|
|
while [[ -n "${gpt_dsk_nmbr}" ]]; do
|
|
if [[ -z "${instl_drive}" ]]; then
|
|
ask "Select a disk to manage its GPT"
|
|
NC "\n\n${disks}"
|
|
get "Enter a disk number ${bwhite}(empty to skip)"
|
|
read -r -p "==> " gpt_dsk_nmbr
|
|
if [[ -n "${gpt_dsk_nmbr}" ]]; then
|
|
gptdrive="$(echo "${disks}" | awk "\$1 == ${gpt_dsk_nmbr} {print \$2}")"
|
|
else
|
|
skip
|
|
ok
|
|
if [[ "${install}" == "yes" ]]; then
|
|
until instl_dsk; do : ; done
|
|
return 0
|
|
else
|
|
until dsks_submn; do : ; done
|
|
return 0
|
|
fi
|
|
fi
|
|
fi
|
|
if [[ -n "${instl_drive}" ]]; then
|
|
gptdrive="${instl_drive}"
|
|
fi
|
|
if [[ -e "${gptdrive}" ]]; then
|
|
parttable="$(fdisk -l "${gptdrive}" 2> "${void}" | grep '^Disklabel type' | awk "{print \$3}")"
|
|
if [[ "${run_as}" != "root" ]]; then
|
|
err "Root Privileges Missing.."
|
|
reload
|
|
until dsks_submn; do : ; done
|
|
fi
|
|
if [[ "${parttable}" == "gpt" ]]; then
|
|
msg "Disk GPT OK"
|
|
elif [[ "${parttable}" != "gpt" && -z "${install}" ]]; then
|
|
err "No GPT detected on selected disk"
|
|
fi
|
|
ask "Make a Selection"
|
|
NC "\n\n [1] Create new GPT on selected disk [Destroy any existing GPT/MBR structures]\n\n [2] Use the 'gdisk' program interactively [Expert Mode]\n\n [ ] Return to Previous Menu"
|
|
get "Enter a number"
|
|
read -r -p "==> " gptslct
|
|
if [[ "${gptslct}" == "1" ]]; then
|
|
sgdisk -Z "${gptdrive}" > "${void}" &&
|
|
sgdisk -o "${gptdrive}" > "${void}" &&
|
|
parttable="$(fdisk -l "${gptdrive}" 2> "${void}" | grep '^Disklabel type' | awk "{print \$3}")"
|
|
if [[ "${parttable}" == "gpt" ]]; then
|
|
multibooting="n"
|
|
nowarning="y"
|
|
gptok="yes"
|
|
local prompt="GPT"
|
|
ok
|
|
if [[ "${install}" == "yes" ]]; then
|
|
until instl_dsk; do : ; done
|
|
return 0
|
|
else
|
|
until dsks_submn; do : ; done
|
|
return 0
|
|
fi
|
|
else
|
|
gptok="no"
|
|
err "No GPT detected on selected disk"
|
|
reload
|
|
return 1
|
|
fi
|
|
elif [[ "${gptslct}" == "2" ]]; then
|
|
ack "Type ${nc}'?'${yellow} for help, ${nc}'x'${yellow} for extra functionality or ${nc}'q'${yellow} to quit"
|
|
NC "\n_______________________________________________\n"
|
|
gdisk "${gptdrive}"
|
|
parttable="$(fdisk -l "${gptdrive}" 2> "${void}" | grep '^Disklabel type' | awk "{print \$3}")"
|
|
if [[ "${parttable}" == "gpt" ]]; then
|
|
multibooting="n"
|
|
nowarning="y"
|
|
gptok="yes"
|
|
local prompt="GPT"
|
|
ok
|
|
if [[ "${install}" == "yes" ]]; then
|
|
until instl_dsk; do : ; done
|
|
return 0
|
|
else
|
|
until dsks_submn; do : ; done
|
|
return 0
|
|
fi
|
|
else
|
|
gptok="no"
|
|
err "No GPT detected on selected disk"
|
|
reload
|
|
return 1
|
|
fi
|
|
elif [[ -z "${gptslct}" ]]; then
|
|
if [[ -n "${instl_drive}" ]]; then
|
|
gptabort="yes"
|
|
skip
|
|
ok
|
|
printf "\n\n"
|
|
until instl_dsk; do : ; done
|
|
return 0
|
|
elif [[ -z "${instl_drive}" ]]; then
|
|
reload
|
|
return 1
|
|
fi
|
|
else
|
|
invalid
|
|
return 1
|
|
fi
|
|
else
|
|
invalid
|
|
return 1
|
|
fi
|
|
done
|
|
}
|
|
ask_multibooting() {
|
|
[[ "${multibooting}" == "n" ]] && return 0
|
|
local prompt="MultiBoot Status"
|
|
title "${prompt}"
|
|
ask "Are you ${nc}Dual${yellow}/${nc}Multi-Booting ${yellow}with other OS's ? [y/n]"
|
|
CYAN "\n\n * ${nc}If ${yellowl}[y]${nc}es, then:${cyan}\n\n >> ${nc}Your ${yellowl}EFI ${nc}System Partition (ESP) will stay ${yellowl}intact${nc}${cyan}\n\n >> ${nc}Only ${yellowl}Manual ${nc}Disk Partitioning will be available for ${yellowl}Disk Management"
|
|
get "Enter [y/n]"
|
|
read -r -p "==> " multibooting
|
|
multibooting="${multibooting,,}"
|
|
case "${multibooting}" in
|
|
y)
|
|
ack "Dual/Multi-Boot selected" ;;
|
|
n)
|
|
ack "No Dual/Multi-Boot" ;;
|
|
"")
|
|
y_n
|
|
return 1 ;;
|
|
*)
|
|
invalid
|
|
return 1 ;;
|
|
esac
|
|
ok
|
|
}
|
|
part_mngr() {
|
|
if [[ "${multibooting}" == "y" ]]; then
|
|
until manual_part; do : ; done
|
|
return 0
|
|
fi
|
|
title "Partition Manager"
|
|
ask "Select a Mode"
|
|
NC "\n\n [1] Automatic Partitioning\n\n [2] Manual Partitioning"
|
|
get "Enter a number"
|
|
read -r -p "==> " part_mode
|
|
case "${part_mode}" in
|
|
1)
|
|
until auto_part; do : ; done ;;
|
|
2)
|
|
until manual_part; do : ; done ;;
|
|
"")
|
|
err "Please select a Mode"
|
|
reload
|
|
return 1 ;;
|
|
*)
|
|
invalid
|
|
return 1 ;;
|
|
esac
|
|
}
|
|
auto_part() {
|
|
title "Automatic Partitioning"
|
|
if [[ -e "${instl_drive}" ]]; then
|
|
if [[ -z "${nowarning}" ]]; then
|
|
delete
|
|
fi
|
|
if [[ "${run_as}" != "root" ]]; then
|
|
err "Root Privileges Missing.."
|
|
reload
|
|
until main_menu; do : ; done
|
|
return 0
|
|
fi
|
|
sgdsk_nmbr="${instl_dsk_nmbr}"
|
|
sgdrive="$(echo "${disks}" | awk "\$1 == ${sgdsk_nmbr} {print \$2}")"
|
|
capacity="$(fdisk -l "${sgdrive}" | grep -E 'bytes' | grep -E 'Disk' | awk "{print \$5}")"
|
|
cap_gib="$((capacity/1024000000))"
|
|
rootsize="$((capacity*25/100/1024000000))"
|
|
inf "${nc}Apply ${yellowl}'Smart Partitioning' ${nc}on disk ${bwhite}'${instl_drive}'${nc} ? ${cyan}[Y/n]"
|
|
get "Enter [Y/n]"
|
|
read -r -p "==> " smartpart
|
|
smartpart="${smartpart:-y}"
|
|
smartpart="${smartpart,,}"
|
|
if [[ "${smartpart}" == "y" ]]; then
|
|
until smart_presets; do : ; done
|
|
until set_partsize; do : ; done
|
|
until partitioner; do : ; done
|
|
return 0
|
|
elif [[ "${smartpart}" == "n" ]]; then
|
|
inf "Providing ${yellowl}alternatives${nc}.."
|
|
until manual_presets; do : ; done
|
|
until set_partsize; do : ; done
|
|
until partitioner; do : ; done
|
|
return 0
|
|
else
|
|
y_n
|
|
return 1
|
|
fi
|
|
else
|
|
ask "Select a disk for Auto-Partitioning"
|
|
NC "\n\n${disks}"
|
|
get "Enter a disk number ${bwhite}(empty to skip)"
|
|
read -r -p "==> " sgdsk_nmbr
|
|
if [[ -n "${sgdsk_nmbr}" ]]; then
|
|
if [[ "${run_as}" != "root" ]]; then
|
|
err "Root Privileges Missing.."
|
|
reload
|
|
until dsks_submn; do : ; done
|
|
return 0
|
|
fi
|
|
sgdrive="$(echo "${disks}" | awk "\$1 == ${sgdsk_nmbr} {print \$2}")"
|
|
if [[ -e "${sgdrive}" ]]; then
|
|
capacity="$(fdisk -l "${sgdrive}" | grep -E 'bytes' | grep -E 'Disk' | awk "{print \$5}")"
|
|
cap_gib="$((capacity/1024000000))"
|
|
rootsize="$((capacity*25/100/1024000000))"
|
|
until manual_presets; do : ; done
|
|
until set_partsize; do : ; done
|
|
until partitioner; do : ; done
|
|
else
|
|
invalid
|
|
return 1
|
|
fi
|
|
else
|
|
skip
|
|
local prompt="Partition Manager"
|
|
ok
|
|
fi
|
|
fi
|
|
if [[ -z "${sanity}" ]]; then
|
|
until dsks_submn; do : ; done
|
|
return 0
|
|
fi
|
|
}
|
|
smart_presets() {
|
|
if [[ "${fs}" == "1" ]] ; then
|
|
if [[ "${sep_home}" == "y" && "${swapmode}" == "1" ]]; then
|
|
preset="4"
|
|
elif [[ "${sep_home}" == "y" && "${swapmode}" != "1" ]]; then
|
|
preset="3"
|
|
elif [[ "${sep_home}" == "n" && "${swapmode}" == "1" ]]; then
|
|
preset="2"
|
|
elif [[ "${sep_home}" == "n" && "${swapmode}" != "1" ]]; then
|
|
preset="1"
|
|
fi
|
|
elif [[ "${fs}" == "2" ]]; then
|
|
if [[ "${swapmode}" == "1" ]]; then
|
|
preset="2"
|
|
elif [[ "${swapmode}" != "1" ]]; then
|
|
preset="1"
|
|
fi
|
|
fi
|
|
}
|
|
manual_presets() {
|
|
preset=""
|
|
title "Preset Selection"
|
|
if [[ -z "${nowarning}" ]]; then
|
|
delete
|
|
fi
|
|
ask "Select a Partition Layout Preset"
|
|
NC "\n\n ${cyan}* Ext4${nc} compatible layout\n\n ${magenta}* Btrfs${nc} compatible layout"
|
|
NC "\n\n [1] Create ESP & /Root (${cyan}Ext4${nc},${magenta}Btrfs${nc})\n\n [2] Create ESP, /Root & /Swap (${cyan}Ext4${nc},${magenta}Btrfs${nc})\n\n [3] Create ESP, /Root & /Home (${cyan}Ext4${nc})\n\n [4] Create ESP, /Root, /Home & /Swap (${cyan}Ext4${nc})"
|
|
get "Enter a Preset number ${bwhite}(empty to skip)"
|
|
read -r -p "==> " preset
|
|
if [[ "${preset}" =~ ^(1|2|3|4)$ ]]; then
|
|
presetpart="y"
|
|
return 0
|
|
elif [[ -z "${preset}" && "${partok}" == "n" ]]; then
|
|
inf "Providing ${yellowl}alternatives${nc}.."
|
|
manual_part
|
|
return 0
|
|
elif [[ -z "${preset}" ]]; then
|
|
skip
|
|
return 0
|
|
else
|
|
invalid
|
|
return 1
|
|
fi
|
|
}
|
|
set_partsize() {
|
|
[[ "${partok}" == "y" ]] && return 0
|
|
if [[ "${preset}" =~ ^(3|4)$ ]]; then
|
|
sleep 0.2
|
|
CYAN "\n\n\n ### ${nc}Total detected capacity of disk ${yellowl}${sgdrive} ${nc}is ${bwhite}${cap_gib} ${nc}GiB${cyan}\n\n\n ### ${bwhite}Default ${nc}Root partition's size is set to aprox. ${yellowl}25%${nc} of total disk capacity${cyan}\n\n ### ${nc}Root partition's ${bwhite}current ${nc}size will be ${yellowl}[${rootsize} GiB]${nc}"
|
|
ask "Adjust Root Partition's size (by setting a custom ${nc}% ${yellow}value) ?"
|
|
get "Enter ${nc}% ${blue}value ${nc}eg. 40 ${bwhite}(empty to skip)"
|
|
read -r -p "==> " prcnt
|
|
if [[ "${prcnt}" =~ [[:alpha:]] ]]; then
|
|
err "Please use only digits as a value"
|
|
reload
|
|
return 1
|
|
elif [[ -z "${prcnt}" ]]; then
|
|
ack "Default Root Partition's size selected ${nc}[${rootsize} GiB]"
|
|
elif [[ "${prcnt}" -gt "0" && "${prcnt}" -lt "100" ]]; then
|
|
rootsize="$((capacity*"${prcnt}"/100/1024000000))"
|
|
ack "Custom Root Partition's size selected ${nc}[${rootsize} GiB]"
|
|
elif [[ "${prcnt}" == "100" ]]; then
|
|
err "${yellow}WARNING: ${nc}No space left for other partitions.."
|
|
reload
|
|
return 1
|
|
else
|
|
invalid
|
|
return 1
|
|
fi
|
|
fi
|
|
}
|
|
partitioner() {
|
|
[[ "${partok}" == "y" ]] && return 0
|
|
if [[ -z "${preset}" && "${install}" == "yes" ]]; then
|
|
until sanity_check; do : ; done
|
|
return 0
|
|
elif [[ -z "${preset}" ]]; then
|
|
local prompt="Partition Manager"
|
|
ok
|
|
return 0
|
|
fi
|
|
if [[ "${smartpart}" == "y" ]]; then
|
|
local prompt="Disk ${sgdrive} Smart-Partitioned"
|
|
elif [[ "${presetpart}" == "y" ]]; then
|
|
local prompt="Disk ${sgdrive} Preset-Partitioned"
|
|
fi
|
|
local stage_prompt="Partitioning Drive"
|
|
wipefs -afq "${sgdrive}" > "${void}" 2> "${log}" || stage_fail
|
|
if [[ "${gptok}" != "yes" ]]; then
|
|
sgdisk -Z "${sgdrive}" > "${void}" 2> "${log}" || stage_fail
|
|
sgdisk -o "${sgdrive}" > "${void}" 2> "${log}" || stage_fail
|
|
gptok="yes"
|
|
fi
|
|
if [[ "${preset}" == "1" ]]; then
|
|
sgdisk -I -n1:0:+1024M -t1:ef00 -c1:ESP "${sgdrive}" > "${void}" 2> "${log}" || stage_fail
|
|
sgdisk -I -n2:0:0 -t2:8304 -c2:ROOT "${sgdrive}" > "${void}" 2> "${log}" || stage_fail
|
|
partprobe "${sgdrive}" > "${void}" 2> "${log}" || stage_fail
|
|
elif [[ "${preset}" == "2" ]]; then
|
|
until set_swapsize; do : ; done
|
|
sgdisk -I -n1:0:+1024M -t1:ef00 -c1:ESP "${sgdrive}" > "${void}" 2> "${log}" || stage_fail
|
|
sgdisk -I -n2:0:+"${swapsize}"G -t2:8200 -c2:SWAP "${sgdrive}" > "${void}" 2> "${log}" || stage_fail
|
|
sgdisk -I -n3:0:0 -t3:8304 -c3:ROOT "${sgdrive}" > "${void}" 2> "${log}" || stage_fail
|
|
partprobe "${sgdrive}" > "${void}" 2> "${log}" || stage_fail
|
|
elif [[ "${preset}" == "3" ]]; then
|
|
sgdisk -I -n1:0:+1024M -t1:ef00 -c1:ESP "${sgdrive}" > "${void}" 2> "${log}" || stage_fail
|
|
sgdisk -I -n2:0:+"${rootsize}"G -t2:8304 -c2:ROOT "${sgdrive}" > "${void}" 2> "${log}" || stage_fail
|
|
sgdisk -I -n3:0:0 -t3:8302 -c3:HOME "${sgdrive}" > "${void}" 2> "${log}" || stage_fail
|
|
partprobe "${sgdrive}" > "${void}" 2> "${log}" || stage_fail
|
|
elif [[ "${preset}" == "4" ]]; then
|
|
until set_swapsize; do : ; done
|
|
sgdisk -I -n1:0:+1024M -t1:ef00 -c1:ESP "${sgdrive}" > "${void}" 2> "${log}" || stage_fail
|
|
sgdisk -I -n2:0:+"${swapsize}"G -t2:8200 -c2:SWAP "${sgdrive}" > "${void}" 2> "${log}" || stage_fail
|
|
sgdisk -I -n3:0:+"${rootsize}"G -t3:8304 -c3:ROOT "${sgdrive}" > "${void}" 2> "${log}" || stage_fail
|
|
sgdisk -I -n4:0:0 -t4:8302 -c4:HOME "${sgdrive}" > "${void}" 2> "${log}" || stage_fail
|
|
partprobe "${sgdrive}" > "${void}" 2> "${log}" || stage_fail
|
|
fi
|
|
if [[ "${install}" == "yes" ]]; then
|
|
until sanity_check; do : ; done
|
|
else
|
|
ok
|
|
fi
|
|
}
|
|
manual_part() {
|
|
title "Manual Partitioning"
|
|
cgdsk_nmbr=" "
|
|
while [[ -n "${cgdsk_nmbr}" ]]; do
|
|
printf "\n\n"
|
|
NC " Supported Partition Types & Mountpoints: "
|
|
printf "\n\n\n"
|
|
RED " Linux Root x86-64 Partition ${nc} [ GUID Code: 8304 ] ${red}Mountpoint: ${nc}/\n"
|
|
BLUE " EFI System Partition ${nc} [ GUID Code: ef00 ] ${blue}Mountpoint: ${nc}/efi or /boot\n"
|
|
GREEN " Linux Home Partition ${nc} [ GUID Code: 8302 ] ${green}Mountpoint: ${nc}/home\n"
|
|
YELLOW " Linux Swap Partition ${nc} [ GUID Code: 8200 ] ${yellow}Mountpoint: ${nc}/swap\n"
|
|
MAGENTA " Linux Extended Boot Partition ${nc} [ GUID Code: ea00 ] ${magenta}Mountpoint: ${nc}/boot\n"
|
|
ask "Select a disk to Manage"
|
|
NC "\n\n${disks}"
|
|
get "Enter a disk number ${bwhite}(empty to skip)"
|
|
read -r -p "==> " cgdsk_nmbr
|
|
if [[ -n "${cgdsk_nmbr}" ]]; then
|
|
cgdrive="$(echo "${disks}" | awk "\$1 == ${cgdsk_nmbr} {print \$2}")"
|
|
if [[ -e "${cgdrive}" ]]; then
|
|
local prompt="Disk ${cgdrive}"
|
|
if [[ "${run_as}" != "root" ]]; then
|
|
err "Root Privileges Missing.."
|
|
reload
|
|
until dsks_submn; do : ; done
|
|
fi
|
|
cgdisk "${cgdrive}"
|
|
clear
|
|
ok
|
|
partprobe "${cgdrive}" > "${void}"
|
|
else
|
|
invalid
|
|
return 1
|
|
fi
|
|
else
|
|
skip
|
|
local prompt="Partition Manager"
|
|
ok
|
|
if [[ -z "${sanity}" ]]; then
|
|
until dsks_submn; do : ; done
|
|
return 0
|
|
elif [[ "${sanity}" == "no" || "${partok}" == "n" ]]; then
|
|
until sanity_check; do : ; done
|
|
return 0
|
|
fi
|
|
fi
|
|
done
|
|
}
|
|
instl_dsk() {
|
|
if [[ ! -e "${instl_drive}" ]]; then
|
|
title "Installation Disk Selection"
|
|
ask "Select a disk to Install to"
|
|
NC "\n\n${disks}"
|
|
get "Enter a disk number"
|
|
read -r -p "==> " instl_dsk_nmbr
|
|
fi
|
|
if [[ -n "${instl_dsk_nmbr}" ]]; then
|
|
instl_drive="$(echo "${disks}" | awk "\$1 == ${instl_dsk_nmbr} {print \$2}")"
|
|
if [[ -e "${instl_drive}" ]]; then
|
|
if [[ "${run_as}" != "root" ]]; then
|
|
err "Root Privileges Missing.."
|
|
reload
|
|
until main_menu; do : ; done
|
|
return 0
|
|
fi
|
|
volumes="$(fdisk -l | grep '^/dev' | cat --number)"
|
|
rota="$(lsblk "${instl_drive}" --nodeps --noheadings --output=rota | awk "{print \$1}")"
|
|
if [[ "${rota}" == "0" ]]; then
|
|
sbvl_mnt_opts="rw,noatime,compress=zstd:1,space_cache=v2"
|
|
trim="fstrim.timer"
|
|
else
|
|
sbvl_mnt_opts="rw,noatime,compress=zstd,space_cache=v2"
|
|
fi
|
|
parttable="$(fdisk -l "${instl_drive}" | grep '^Disklabel type' | awk "{print \$3}")"
|
|
if [[ "${parttable}" != "gpt" && -n "${gptabort}" ]]; then
|
|
err "Please create GPT to continue"
|
|
reload
|
|
until gpt_mngr; do : ; done
|
|
return 0
|
|
elif [[ "${parttable}" != "gpt" ]]; then
|
|
err "No GPT detected on selected disk"
|
|
reload
|
|
until gpt_mngr; do : ; done
|
|
return 0
|
|
fi
|
|
if [[ -z "${multibooting}" ]]; then
|
|
until ask_multibooting; do : ; done
|
|
fi
|
|
until sanity_check; do : ; done
|
|
return 0
|
|
else
|
|
invalid
|
|
return 1
|
|
fi
|
|
else
|
|
err "Please select Installation Disk"
|
|
reload
|
|
return 1
|
|
fi
|
|
}
|
|
sanity_check() {
|
|
rootcount="$(fdisk -l "${instl_drive}" | grep -E -c 'root' | awk "{print \$1}")"
|
|
root_dev="$(fdisk -l "${instl_drive}" | grep -E 'root' | awk "{print \$1}")"
|
|
multi_root="$(fdisk -l "${instl_drive}" | grep -E 'root' | awk "{print \$1}" | cat --number)"
|
|
root_comply="$(fdisk -l "${instl_drive}" | grep -E 'root' | awk "{print \$1}" | cat --number | grep -E '1[[:blank:]]' | awk "{print \$2}")"
|
|
espcount="$(fdisk -l "${instl_drive}" | grep -E -c 'EFI' | awk "{print \$1}")"
|
|
esp_dev="$(fdisk -l "${instl_drive}" | grep -E 'EFI' | awk "{print \$1}")"
|
|
multi_esp="$(fdisk -l "${instl_drive}" | grep -E 'EFI' | awk "{print \$1}" | cat --number)"
|
|
esp_comply="$(fdisk -l "${instl_drive}" | grep -E 'EFI' | awk "{print \$1}" | cat --number | grep -E '1[[:blank:]]' | awk "{print \$2}")"
|
|
xbootcount="$(fdisk -l "${instl_drive}" | grep -E -c 'extended' | awk "{print \$1}")"
|
|
xboot_dev="$(fdisk -l "${instl_drive}" | grep -E 'extended' | awk "{print \$1}")"
|
|
multi_xboot="$(fdisk -l "${instl_drive}" | grep -E 'extended' | awk "{print \$1}" | cat --number)"
|
|
xboot_comply="$(fdisk -l "${instl_drive}" | grep -E 'extended' | awk "{print \$1}" | cat --number | grep -E '1[[:blank:]]' | awk "{print \$2}")"
|
|
homecount="$(fdisk -l "${instl_drive}" | grep -E -c 'home' | awk "{print \$1}")"
|
|
home_dev="$(fdisk -l "${instl_drive}" | grep -E 'home' | awk "{print \$1}")"
|
|
multi_home="$(fdisk -l "${instl_drive}" | grep -E 'home' | awk "{print \$1}" | cat --number)"
|
|
home_comply="$(fdisk -l "${instl_drive}" | grep -E 'home' | awk "{print \$1}" | cat --number | grep -E '1[[:blank:]]' | awk "{print \$2}")"
|
|
swapcount="$(fdisk -l "${instl_drive}" | grep -E -c 'swap' | awk "{print \$1}")"
|
|
swap_dev="$(fdisk -l "${instl_drive}" | grep -E 'swap' | awk "{print \$1}")"
|
|
multi_swap="$(fdisk -l "${instl_drive}" | grep -E 'swap' | awk "{print \$1}" | cat --number)"
|
|
swap_comply="$(fdisk -l "${instl_drive}" | grep -E 'swap' | awk "{print \$1}" | cat --number | grep -E '1[[:blank:]]' | awk "{print \$2}")"
|
|
rootprt=""
|
|
espprt=""
|
|
xbootprt=""
|
|
homeprt=""
|
|
swapprt=""
|
|
title "Sanity Check"
|
|
[[ "${rootcount}" == "1" || "${espcount}" == "1" || "${xbootcount}" == "1" || "${homecount}" == "1" || "${swapcount}" == "1" ]] && echo
|
|
# ATTENTION: MULTI-ROOT
|
|
if [[ "${rootcount}" -gt "1" ]]; then
|
|
local color="${greenl}"
|
|
local type="Linux x86-64 /Root"
|
|
local multi_type="${multi_root}"
|
|
local type_comply="${root_comply}"
|
|
local length="${#root_dev}"
|
|
dashes="$(printf '%*s' "$length" '' | tr ' ' '-')"
|
|
local dashline="${nc}${dashes}"
|
|
action="${red}[!] ${bwhite}FORMATTED ${nc}${red}[!]"
|
|
multi_info
|
|
get "Proceed ? [Y/n]"
|
|
read -r -p "==> " autoroot
|
|
autoroot="${autoroot:-y}"
|
|
autoroot="${autoroot,,}"
|
|
if [[ "${autoroot}" == "y" ]]; then
|
|
root_dev="${root_comply}"
|
|
multiroot_bootopts="root=PARTUUID=$(blkid -s PARTUUID -o value "${root_dev}")"
|
|
elif [[ "${autoroot}" == "n" ]]; then
|
|
until auto_part; do : ; done
|
|
return 0
|
|
else
|
|
y_n
|
|
return 1
|
|
fi
|
|
fi
|
|
# ATTENTION: MULTI-ESP
|
|
if [[ "${espcount}" -gt "1" ]]; then
|
|
if [[ "${multibooting}" == "n" ]]; then
|
|
action="${red}[!] ${bwhite}FORMATTED ${nc}${red}[!]"
|
|
elif [[ "${multibooting}" == "y" ]]; then
|
|
action="used in the installation"
|
|
fi
|
|
local color="${cyanl}"
|
|
local type="EFI System"
|
|
local multi_type="${multi_esp}"
|
|
local type_comply="${esp_comply}"
|
|
local length="${#esp_dev}"
|
|
dashes="$(printf '%*s' "$length" '' | tr ' ' '-')"
|
|
local dashline="${nc}${dashes}"
|
|
multi_info
|
|
get "Proceed ? [Y/n]"
|
|
read -r -p "==> " autoesp
|
|
autoesp="${autoesp:-y}"
|
|
autoesp="${autoesp,,}"
|
|
if [[ "${autoesp}" == "y" ]]; then
|
|
esp_dev="${esp_comply}"
|
|
elif [[ "${autoesp}" == "n" ]]; then
|
|
until auto_part; do : ; done
|
|
return 0
|
|
else
|
|
y_n
|
|
return 1
|
|
fi
|
|
fi
|
|
# ATTENTION: MULTI-XBOOTLDR
|
|
if [[ "${xbootcount}" -gt "1" ]]; then
|
|
local color="${redl}"
|
|
local type="Linux Extended Boot"
|
|
local multi_type="${multi_xboot}"
|
|
local type_comply="${xboot_comply}"
|
|
local length="${#xboot_dev}"
|
|
dashes="$(printf '%*s' "$length" '' | tr ' ' '-')"
|
|
local dashline="${nc}${dashes}"
|
|
action="${red}[!] ${bwhite}FORMATTED ${nc}${red}[!]"
|
|
multi_info
|
|
get "Proceed ? [Y/n]"
|
|
read -r -p "==> " autoxboot
|
|
autoxboot="${autoxboot:-y}"
|
|
autoxboot="${autoxboot,,}"
|
|
if [[ "${autoxboot}" == "y" ]]; then
|
|
xboot_dev="${xboot_comply}"
|
|
elif [[ "${autoxboot}" == "n" ]]; then
|
|
until auto_part; do : ; done
|
|
return 0
|
|
else
|
|
y_n
|
|
return 1
|
|
fi
|
|
fi
|
|
# ATTENTION: MULTI-HOME
|
|
if [[ "${fs}" == "1" && "${sep_home}" == "y" && "${homecount}" -gt "1" ]]; then
|
|
local color="${magental}"
|
|
local type="Linux /Home"
|
|
local multi_type="${multi_home}"
|
|
local type_comply="${home_comply}"
|
|
local length="${#home_dev}"
|
|
dashes="$(printf '%*s' "$length" '' | tr ' ' '-')"
|
|
local dashline="${nc}${dashes}"
|
|
action="used in the installation"
|
|
multi_info
|
|
get "Proceed ? [Y/n]"
|
|
read -r -p "==> " autohome
|
|
autohome="${autohome:-y}"
|
|
autohome="${autohome,,}"
|
|
if [[ "${autohome}" == "y" ]]; then
|
|
home_dev="${home_comply}"
|
|
elif [[ "${autohome}" == "n" ]]; then
|
|
until auto_part; do : ; done
|
|
return 0
|
|
else
|
|
y_n
|
|
return 1
|
|
fi
|
|
fi
|
|
# ATTENTION: MULTI-SWAP
|
|
if [[ "${swapmode}" == "1" && "${swapcount}" -gt "1" ]]; then
|
|
local color="${yellowl}"
|
|
local type="Linux /Swap"
|
|
local multi_type="${multi_swap}"
|
|
local type_comply="${swap_comply}"
|
|
local length="${#swap_dev}"
|
|
dashes="$(printf '%*s' "$length" '' | tr ' ' '-')"
|
|
local dashline="${nc}${dashes}"
|
|
action="${red}[!] ${bwhite}FORMATTED ${nc}${red}[!]"
|
|
multi_info
|
|
get "Proceed ? [Y/n]"
|
|
read -r -p "==> " autoswap
|
|
autoswap="${autoswap:-y}"
|
|
autoswap="${autoswap,,}"
|
|
if [[ "${autoswap}" == "y" ]]; then
|
|
swap_dev="${swap_comply}"
|
|
elif [[ "${autoswap}" == "n" ]]; then
|
|
until auto_part; do : ; done
|
|
return 0
|
|
else
|
|
y_n
|
|
return 1
|
|
fi
|
|
fi
|
|
# ATTENTION: ROOT
|
|
if [[ -e "${root_dev}" ]]; then
|
|
rootpartsize="$(lsblk -dno SIZE --bytes "${root_dev}")"
|
|
if [[ "${rootpartsize}" -ge "8589934592" ]]; then
|
|
rootprt="ok"
|
|
else
|
|
rootprt="ok"
|
|
sleep 0.2
|
|
CYAN "\n >> ${yellowl}WARNING: ${nc}/Root's size might not be adequate"
|
|
sleep 0.2
|
|
CYAN "\n
|
|
>> ${nc}Depending on the ${yellowl}size ${nc}of your setup, installation might ${yellowl}fail\n"
|
|
keypress
|
|
fi
|
|
if [[ "${autoroot}" == "y" ]]; then
|
|
if [[ "${presetpart}" == "y" || "${smartpart}" == "y" ]]; then
|
|
rootprt="ok"
|
|
sleep 0.2
|
|
GREEN "\n >> ${nc}Linux x86-64 /Root partition ${green}OK"
|
|
else
|
|
rootprt="ok"
|
|
sleep 0.2
|
|
GREEN "\n >> ${yellowl}Confirmed ${nc}Linux x86-64 /Root partition ${green}OK"
|
|
fi
|
|
else
|
|
sleep 0.2
|
|
rootprt="ok"
|
|
GREEN "\n >> ${nc}Linux x86-64 /Root partition ${green}OK"
|
|
fi
|
|
else
|
|
rootprt="fail"
|
|
sleep 0.2
|
|
RED "\n >> ${yellowl}Linux x86-64 /Root ${nc}partition not detected"
|
|
fi
|
|
# ATTENTION: ESP
|
|
if [[ ! -e "${esp_dev}" ]]; then
|
|
espprt="fail"
|
|
sleep 0.2
|
|
RED "\n >> ${yellowl}/EFI System ${nc}partition not detected"
|
|
fi
|
|
if [[ -e "${esp_dev}" ]]; then
|
|
espsize="$(lsblk -dno SIZE --bytes "${esp_dev}")"
|
|
fi
|
|
if [[ -e "${esp_dev}" && "${espsize}" -ge "209715200" ]]; then
|
|
espprt="ok"
|
|
xbootloader="no"
|
|
if [[ "${autoesp}" == "y" ]]; then
|
|
if [[ "${presetpart}" == "y" || "${smartpart}" == "y" ]]; then
|
|
espprt="ok"
|
|
sleep 0.2
|
|
GREEN "\n >> ${nc}/EFI System partition ${green}OK"
|
|
else
|
|
espprt="ok"
|
|
sleep 0.2
|
|
GREEN "\n >> ${yellowl}Confirmed ${nc}/EFI System partition ${green}OK"
|
|
fi
|
|
else
|
|
espprt="ok"
|
|
sleep 0.2
|
|
GREEN "\n >> ${nc}/EFI System partition ${green}OK"
|
|
fi
|
|
fi
|
|
if [[ -e "${esp_dev}" && "${espsize}" -lt "209715200" ]]; then
|
|
if [[ "${bootloader}" == "1" ]]; then
|
|
if [[ "${multibooting}" == "y" ]]; then
|
|
xbootloader="yes"
|
|
if [[ -e "${xboot_dev}" ]]; then
|
|
xbootprt="ok"
|
|
espprt="ok"
|
|
if [[ "${autoesp}" == "y" ]]; then
|
|
if [[ "${presetpart}" == "y" || "${smartpart}" == "y" ]]; then
|
|
espprt="ok"
|
|
sleep 0.2
|
|
GREEN "\n >> ${nc}/EFI System partition ${green}OK"
|
|
else
|
|
espprt="ok"
|
|
sleep 0.2
|
|
GREEN "\n >> ${yellowl}Confirmed ${nc}/EFI System partition ${green}OK"
|
|
fi
|
|
else
|
|
espprt="ok"
|
|
sleep 0.2
|
|
GREEN "\n >> ${nc}/EFI System partition ${green}OK"
|
|
fi
|
|
if [[ "${autoxboot}" == "y" ]]; then
|
|
if [[ "${presetpart}" == "y" || "${smartpart}" == "y" ]]; then
|
|
sleep 0.2
|
|
GREEN "\n >> ${nc}Linux /Extended Boot partition ${green}OK"
|
|
else
|
|
sleep 0.2
|
|
GREEN "\n >> ${yellowl}Confirmed ${nc}Linux /Extended Boot partition ${green}OK"
|
|
fi
|
|
else
|
|
sleep 0.2
|
|
GREEN "\n >> ${nc}Linux /Extended Boot partition ${green}OK"
|
|
fi
|
|
else
|
|
xbootprt="fail"
|
|
espprt="fail"
|
|
sleep 0.2
|
|
CYAN "\n >> ${yellowl}WARNING: ${nc}ESP's size is not ${bwhite}adequate"
|
|
sleep 0.2
|
|
RED "\n >> ${yellowl}Linux /Extended Boot ${nc}partition not detected"
|
|
fi
|
|
elif [[ "${multibooting}" == "n" ]]; then
|
|
espprt="fail"
|
|
xbootloader="no"
|
|
sleep 0.2
|
|
CYAN "\n >> ${yellowl}WARNING: ${nc}ESP's size is not ${bwhite}adequate"
|
|
fi
|
|
elif [[ "${bootloader}" == "2" ]]; then
|
|
if [[ "${espmnt}" == "2" ]]; then
|
|
espprt="fail"
|
|
xbootloader="no"
|
|
sleep 0.2
|
|
CYAN "\n >> ${yellowl}WARNING: ${nc}ESP's size is not ${bwhite}adequate"
|
|
elif [[ "${espmnt}" == "1" ]]; then
|
|
espprt="ok"
|
|
xbootloader="no"
|
|
if [[ "${autoesp}" == "y" ]]; then
|
|
if [[ "${presetpart}" == "y" || "${smartpart}" == "y" ]]; then
|
|
sleep 0.2
|
|
GREEN "\n >> ${nc}/EFI System partition ${green}OK"
|
|
else
|
|
sleep 0.2
|
|
GREEN "\n >> ${yellowl}Confirmed ${nc}/EFI System partition ${green}OK"
|
|
fi
|
|
else
|
|
sleep 0.2
|
|
GREEN "\n >> ${nc}/EFI System partition ${green}OK"
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
# ATTENTION: HOME
|
|
if [[ "${fs}" == "1" ]]; then
|
|
if [[ "${sep_home}" == "y" ]]; then
|
|
if [[ -e "${home_dev}" ]]; then
|
|
homeprt="ok"
|
|
if [[ "${autohome}" == "y" ]]; then
|
|
if [[ "${presetpart}" == "y" || "${smartpart}" == "y" ]]; then
|
|
sleep 0.2
|
|
GREEN "\n >> ${nc}Linux /Home partition ${green}OK"
|
|
else
|
|
sleep 0.2
|
|
GREEN "\n >> ${yellowl}Confirmed ${nc}Linux /Home partition ${green}OK"
|
|
fi
|
|
else
|
|
GREEN "\n >> ${nc}Linux /Home partition ${green}OK"
|
|
fi
|
|
else
|
|
homeprt="fail"
|
|
sleep 0.2
|
|
RED "\n >> ${yellowl}Linux /Home ${nc}partition not detected"
|
|
fi
|
|
fi
|
|
fi
|
|
# ATTENTION: SWAP
|
|
if [[ "${swapmode}" == "1" ]]; then
|
|
if [[ -e "${swap_dev}" ]]; then
|
|
swapprt="ok"
|
|
if [[ "${autoswap}" == "y" ]]; then
|
|
if [[ "${presetpart}" == "y" || "${smartpart}" == "y" ]]; then
|
|
sleep 0.2
|
|
GREEN "\n >> ${nc}Linux /Swap partition ${green}OK"
|
|
else
|
|
sleep 0.2
|
|
GREEN "\n >> ${yellowl}Confirmed ${nc}Linux /Swap partition ${green}OK"
|
|
fi
|
|
else
|
|
sleep 0.2
|
|
GREEN "\n >> ${nc}Linux /Swap partition ${green}OK"
|
|
fi
|
|
else
|
|
swapprt="fail"
|
|
sleep 0.2
|
|
RED "\n >> ${yellowl}Linux /Swap ${nc}partition not detected"
|
|
fi
|
|
fi
|
|
if [[ "${rootprt}" == "fail" || "${espprt}" == "fail" || "${xbootprt}" == "fail" || "${homeprt}" == "fail" || "${swapprt}" == "fail" ]]; then
|
|
sanity="no"
|
|
else
|
|
sanity="ok"
|
|
fi
|
|
# ATTENTION: SANITY CHECK OK
|
|
if [[ "${sanity}" == "ok" ]]; then
|
|
if [[ "${smartpart}" == "y" ]]; then
|
|
local prompt="Disk ${sgdrive} Smart-Partitioned"
|
|
ok
|
|
elif [[ "${presetpart}" == "y" ]]; then
|
|
local prompt="Disk ${sgdrive} Preset-Partitioned"
|
|
ok
|
|
fi
|
|
msg "SANITY CHECK OK"
|
|
printf "\n\n"
|
|
disk_overview
|
|
get "Proceed using the ${nc}${cyan}current ${blue}partitioning layout ? [Y/n]"
|
|
read -r -p "==> " partok
|
|
partok="${partok:-y}"
|
|
partok="${partok,,}"
|
|
local prompt="Disk Partitioning"
|
|
local stage_prompt="Partitioning"
|
|
if [[ "${partok}" == "y" ]]; then
|
|
ok
|
|
return 0
|
|
elif [[ "${partok}" == "n" ]]; then
|
|
if [[ "${multibooting}" == "n" && "${hometype}" == "1" ]]; then
|
|
reload
|
|
until auto_part; do : ; done
|
|
return 0
|
|
elif [[ "${multibooting}" == "n" && "${hometype}" == "2" ]]; then
|
|
reload
|
|
until manual_part; do : ; done
|
|
return 0
|
|
elif [[ "${multibooting}" == "n" ]]; then
|
|
reload
|
|
until auto_part; do : ; done
|
|
return 0
|
|
elif [[ "${multibooting}" == "y" ]]; then
|
|
reload
|
|
until manual_part; do : ; done
|
|
return 0
|
|
fi
|
|
else
|
|
y_n
|
|
return 1
|
|
fi
|
|
# ATTENTION; SANITY CHECK FAIL
|
|
elif [[ "${sanity}" == "no" ]]; then
|
|
err "SANITY CHECK FAILED"
|
|
keypress
|
|
if [[ "${multibooting}" == "y" ]]; then
|
|
if [[ "${espprt}" == "fail" && -e "${esp_dev}" ]]; then
|
|
sleep 0.2
|
|
CYAN "\n >> ${yellowl}ESP: ${nc}Not all prerequisites are satisfied"
|
|
if [[ "${espmnt}" == "2" ]]; then
|
|
sleep 0.2
|
|
CYAN "\n\n >> ${nc}Select ${yellowl}/mnt/efi ${nc}as the mountpoint for your ${yellowl}ESP"
|
|
fi
|
|
if [[ "${xbootprt}" == "fail" ]]; then
|
|
sleep 0.2
|
|
CYAN "\n\n >> ${yellowl}Systemd-boot:${nc}${cyan}\n\n >> ${nc}Create a ${yellowl}300M ${nc}(at minimum) Linux Extended Boot Partition ${bwhite}(XBOOTLDR) ${yellowl}[GUID CODE: ea00]\n"
|
|
fi
|
|
keypress
|
|
if [[ "${espmnt}" == "2" ]]; then
|
|
until slct_espmnt; do : ; done
|
|
fi
|
|
if [[ "${xbootprt}" == "fail" ]]; then
|
|
until manual_part; do : ; done
|
|
fi
|
|
elif [[ "${espprt}" == "fail" && ! -e "${esp_dev}" ]]; then
|
|
reload
|
|
until manual_part; do : ; done
|
|
elif [[ "${homeprt}" == "fail" || "${swapprt}" == "fail" ]]; then
|
|
reload
|
|
until manual_part; do : ; done
|
|
fi
|
|
elif [[ "${multibooting}" == "n" ]]; then
|
|
if [[ -z "${hometype}" || "${hometype}" == "1" ]]; then
|
|
reload
|
|
until auto_part; do : ; done
|
|
else
|
|
reload
|
|
until manual_part; do : ; done
|
|
fi
|
|
fi
|
|
fi
|
|
}
|
|
ask_crypt() {
|
|
local prompt="Encryption Setup"
|
|
LuksArray=(Root)
|
|
[[ "${hometype}" == "1" ]] && LuksArray+=(Home)
|
|
[[ "${swapmode}" == "1" ]] && LuksArray+=(Swap)
|
|
delimiter=""
|
|
LuksParts=""
|
|
for item in "${LuksArray[@]}"; do
|
|
LuksParts="$LuksParts$delimiter$item"
|
|
delimiter=","
|
|
done
|
|
title "Encryption Setup"
|
|
ask "Utilize LUKS encryption for your system ?"
|
|
NC "\n\n * Type '${cyan}no${nc}' to proceed without encryption\n\n * Type '${cyan}yes${nc}' to encrypt your ${yellowl}${LuksParts}\n"
|
|
read -r -p "==> " encrypt
|
|
if [[ "${encrypt}" == "no" ]]; then
|
|
skip
|
|
ok
|
|
printf "\n\n"
|
|
return 0
|
|
elif [[ "${encrypt}" == "yes" ]]; then
|
|
if [[ "${bootloader}" == "2" && "${espmnt}" == "1" ]]; then
|
|
err "Incompatible Selection detected"
|
|
ack "ESP cannot be mounted on ${nc}'/efi' ${yellow}when using Grub on a LUKS encrypted Root partition"
|
|
ask "Change ESP mountpoint to ${nc}'/boot' ${yellow}instead ? [Y/n]"
|
|
get "Enter [Y/n]"
|
|
read -r -p "==> " cng_espmnt
|
|
cng_espmnt="${cng_espmnt:-y}"
|
|
cng_espmnt="${cng_espmnt,,}"
|
|
if [[ "${cng_espmnt}" == "y" ]]; then
|
|
espmnt="2"
|
|
esp_mount="/mnt/boot"
|
|
btldr_esp_mount="/boot"
|
|
ack "'/mnt/boot' mountpoint has been selected"
|
|
elif [[ "${cng_espmnt}" == "n" ]]; then
|
|
failure
|
|
else
|
|
y_n
|
|
return 1
|
|
fi
|
|
fi
|
|
ask "Set your LUKS encryption password"
|
|
get "Enter password"
|
|
read -r -p "==> " CRYPTPASS
|
|
sleep 0.2
|
|
ask "Verify your LUKS encryption password"
|
|
get "Re-enter password"
|
|
read -r -p "==> " CRYPTPASS2
|
|
if [[ "${CRYPTPASS}" != "${CRYPTPASS2}" ]]; then
|
|
err "Passwords don't match. Please try again.."
|
|
reload
|
|
return 1
|
|
fi
|
|
ok
|
|
else
|
|
yes_no
|
|
return 1
|
|
fi
|
|
}
|
|
instl() {
|
|
install="yes"
|
|
if [[ -z "${lcl_slct}" ]]; then
|
|
local stage_prompt="Locale & Keyboard Layout Selection"
|
|
completion_err
|
|
until slct_locale; do : ; done
|
|
until slct_kbd; do : ; done
|
|
fi
|
|
if [[ -z "${USERNAME}" ]]; then
|
|
local stage_prompt="User, Root User, Hostname & Shell Setup"
|
|
completion_err
|
|
until user_setup; do : ; done
|
|
until rootuser_setup; do : ; done
|
|
until slct_hostname; do : ; done
|
|
until slct_shell; do : ; done
|
|
fi
|
|
if [[ -z "${kernelnmbr}" || "${revision}" == "y" ]]; then
|
|
local stage_prompt="Kernel, Secureboot Signing, Bootloader & ESP Mountpoint"
|
|
completion_err
|
|
until slct_krnl; do : ; done
|
|
until ask_sign; do : ; done
|
|
until slct_bootldr; do : ; done
|
|
until slct_espmnt; do : ; done
|
|
fi
|
|
if [[ -z "${fs}" || "${revision}" == "y" ]]; then
|
|
local stage_prompt="Filesystem & Swap Setup"
|
|
completion_err
|
|
until slct_fs; do : ; done
|
|
until slct_swap; do : ; done
|
|
fi
|
|
if [[ "${vendor}" != "Virtual Machine" && -z "${gfx_slct}" ]] || [[ "${vendor}" != "Virtual Machine" && "${revision}" == "y" ]]; then
|
|
local stage_prompt="Graphics Setup"
|
|
completion_err
|
|
until dtct_gfx; do : ; done
|
|
fi
|
|
if [[ -z "${desktop}" || "${revision}" == "y" ]]; then
|
|
local stage_prompt="Desktop Setup"
|
|
completion_err
|
|
until dsktp_slct; do : ; done
|
|
fi
|
|
if [[ -z "${dev}" || "${revision}" == "y" ]]; then
|
|
until base_devel; do : ; done
|
|
fi
|
|
if [[ -z "${web_slct}" || "${revision}" == "y" ]]; then
|
|
if [[ ! "${desktop}" =~ ^(11|12)$ ]]; then
|
|
until web_browser; do : ; done
|
|
fi
|
|
fi
|
|
if [[ "${vendor}" != "Virtual Machine" ]]; then
|
|
if [[ -z "${printer}" || "${revision}" == "y" ]]; then
|
|
if [[ ! "${desktop}" =~ ^(11|12)$ ]]; then
|
|
until print_scan; do : ; done
|
|
fi
|
|
fi
|
|
if [[ -z "${efi_entr_del}" || "${revision}" == "y" ]]; then
|
|
local stage_prompt="EFI Boot Entries Deletion"
|
|
completion_err
|
|
until boot_entr; do : ; done
|
|
fi
|
|
fi
|
|
if [[ -z "${show_extopts}" ]]; then
|
|
local stage_prompt="Extended Options"
|
|
completion_err
|
|
until display_ext_opt; do : ; done
|
|
if [[ "${show_extopts}" == "y" ]]; then
|
|
until cust_kern_param; do : ; done
|
|
until sys_watchdog; do : ; done
|
|
until sysoptm; do : ; done
|
|
if [[ "${vendor}" != "Virtual Machine" ]]; then
|
|
until ask_wireless_regdom; do : ; done
|
|
fi
|
|
until systemd_oomd; do : ; done
|
|
until irqbalance; do : ; done
|
|
until thermald; do : ; done
|
|
until rngd; do : ; done
|
|
until rtkit; do : ; done
|
|
if [[ "${vendor}" != "Virtual Machine" ]]; then
|
|
until tlp; do : ; done
|
|
fi
|
|
fi
|
|
fi
|
|
until instl_dsk; do : ; done
|
|
until ask_crypt; do : ; done
|
|
if [[ "${swapmode}" == "1" ]]; then
|
|
until "${swaptype}"; do : ; done
|
|
fi
|
|
if [[ "${encrypt}" == "no" ]]; then
|
|
until set_mode; do : ; done
|
|
elif [[ "${encrypt}" == "yes" ]]; then
|
|
until sec_erase; do : ; done
|
|
until luks; do : ; done
|
|
fi
|
|
until opt_pcmn; do : ; done
|
|
until pacstrap_system; do : ; done
|
|
if [[ "${swapmode}" == "2" ]]; then
|
|
until "${swaptype}"; do : ; done
|
|
fi
|
|
if [[ -n "${REGDOM}" ]]; then
|
|
until set_wireless_regdom; do : ; done
|
|
fi
|
|
set_vars
|
|
chroot_conf
|
|
completion
|
|
installation="ok"
|
|
umount -R /mnt
|
|
reboot
|
|
}
|
|
swappart() {
|
|
if [[ "${encrypt}" == "yes" ]]; then
|
|
printf "\n\n"
|
|
fi
|
|
local prompt="Swap Partition Creation"
|
|
local stage_prompt="Swap Partition Creation"
|
|
sleep 0.2
|
|
NC "\n${magenta}###${nc}----------------------------------${magenta}[ ${bwhite}Swap Partition Setup${nc} ${magenta}]${nc}----------------------------------${magenta}###\n"
|
|
if mkswap "${swap_dev}" > "${void}" 2> "${log}" ; then
|
|
ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
}
|
|
set_mode() {
|
|
if [[ "${rootcount}" -gt "1" || "${espcount}" -gt "1" || "${xbootcount}" -gt "1" || "${homecount}" -gt "1" || "${swapcount}" -gt "1" ]]; then
|
|
until auto_mode; do : ; done
|
|
local prompt="Filesystems"
|
|
ok
|
|
filesystem_overview
|
|
return 0
|
|
fi
|
|
title "Mode Selection"
|
|
ask "Select a Mode to continue"
|
|
NC "\n\n [1] Auto (Automatically Format, Label & Mount partitions)\n\n [2] Manual (Manually Format, Label & Mount partitions)"
|
|
get "Enter a Mode number"
|
|
read -r -p "==> " setmode
|
|
case "${setmode}" in
|
|
1)
|
|
until auto_mode; do : ; done ;;
|
|
2)
|
|
until manual_mode; do : ; done ;;
|
|
"")
|
|
err "Please select a Mode to continue"
|
|
reload
|
|
return 1 ;;
|
|
*)
|
|
invalid
|
|
return 1 ;;
|
|
esac
|
|
local prompt="Filesystems"
|
|
ok
|
|
filesystem_overview
|
|
}
|
|
auto_mode() {
|
|
if [[ "${swapmode}" == "1" ]]; then
|
|
printf "\n\n"
|
|
fi
|
|
espfs="$(lsblk -dno FSTYPE "${esp_dev}")"
|
|
sleep 0.2
|
|
NC "\n${magenta}###${nc}----------------------------------------${magenta}[ ${bwhite}Auto Mode${nc} ${magenta}]${nc}----------------------------------------${magenta}###\n"
|
|
sleep 0.2
|
|
YELLOW "\n\n > Auto Mode Selected\n\n"
|
|
if [[ "${fs}" == "1" ]]; then
|
|
if mkfs.ext4 -F -L Root "${root_dev}" > "${void}" 2> "${log}" ; then
|
|
tune2fs -O fast_commit "${root_dev}" > "${void}" 2> "${log}" || err_abort
|
|
mount "${root_dev}" /mnt > "${void}" 2> "${log}" || err_abort
|
|
sleep 0.2
|
|
NC "\n==> [${green}/Root OK${nc}]"
|
|
else
|
|
umount_manual
|
|
until form_root; do : ; done
|
|
until mount_mnt; do : ; done
|
|
fi
|
|
elif [[ "${fs}" == "2" ]]; then
|
|
if mkfs.btrfs -f -L Root "${root_dev}" > "${void}" 2> "${log}" ; then
|
|
mount "${root_dev}" /mnt > "${void}" 2> "${log}" || err_abort
|
|
btrfs subvolume create /mnt/@ > "${void}" 2> "${log}" || err_abort
|
|
btrfs subvolume create /mnt/@home > "${void}" 2> "${log}" || err_abort
|
|
btrfs subvolume create /mnt/@cache > "${void}" 2> "${log}" || err_abort
|
|
btrfs subvolume create /mnt/@log > "${void}" 2> "${log}" || err_abort
|
|
btrfs subvolume create /mnt/@tmp > "${void}" 2> "${log}" || err_abort
|
|
btrfs subvolume create /mnt/@snapshots > "${void}" 2> "${log}" || err_abort
|
|
if [[ "${swapmode}" == "2" ]]; then
|
|
btrfs subvolume create /mnt/@swap > "${void}" 2> "${log}" || err_abort
|
|
fi
|
|
umount /mnt > "${void}" 2> "${log}" || err_abort
|
|
mount -o "${sbvl_mnt_opts}",subvol=@ "${root_dev}" /mnt > "${void}" 2> "${log}" || err_abort
|
|
mount --mkdir -o "${sbvl_mnt_opts}",subvol=@home "${root_dev}" /mnt/home > "${void}" 2> "${log}" || err_abort
|
|
mount --mkdir -o "${sbvl_mnt_opts}",subvol=@cache "${root_dev}" /mnt/var/cache > "${void}" 2> "${log}" || err_abort
|
|
mount --mkdir -o "${sbvl_mnt_opts}",subvol=@log "${root_dev}" /mnt/var/log > "${void}" 2> "${log}" || err_abort
|
|
mount --mkdir -o "${sbvl_mnt_opts}",subvol=@tmp "${root_dev}" /mnt/var/tmp > "${void}" 2> "${log}" || err_abort
|
|
mount --mkdir -o "${sbvl_mnt_opts}",subvol=@snapshots "${root_dev}" /mnt/"${snapname}" > "${void}" 2> "${log}" || err_abort
|
|
if [[ "${swapmode}" == "2" ]]; then
|
|
mount --mkdir -o "${sbvl_mnt_opts}",subvol=@swap "${root_dev}" /mnt/swap > "${void}" 2> "${log}" || err_abort
|
|
fi
|
|
sleep 0.2
|
|
NC "\n==> [${green}/@ OK${nc}]"
|
|
else
|
|
umount_manual
|
|
until form_root; do : ; done
|
|
until mount_mnt; do : ; done
|
|
fi
|
|
fi
|
|
sleep 0.2
|
|
if [[ "${multibooting}" == "n" ]]; then
|
|
if mkfs.fat -F 32 -n ESP "${esp_dev}" > "${void}" 2> "${log}" ; then
|
|
mount --mkdir "${esp_dev}" "${esp_mount}" > "${void}" 2> "${log}" || err_abort
|
|
sleep 0.2
|
|
NC "\n==> [${green}/ESP OK${nc}]"
|
|
else
|
|
umount_manual
|
|
until form_esp; do : ; done
|
|
until mount_mnt; do : ; done
|
|
until mount_esp; do : ; done
|
|
fi
|
|
elif [[ "${multibooting}" == "y" && "${espfs}" == "vfat" ]]; then
|
|
if mount --mkdir "${esp_dev}" "${esp_mount}" > "${void}" 2> "${log}" ; then
|
|
sleep 0.2
|
|
NC "\n==> [${green}Unformatted /ESP Mounted OK${nc}]"
|
|
else
|
|
umount_manual
|
|
until mount_mnt; do : ; done
|
|
until mount_esp; do : ; done
|
|
fi
|
|
elif [[ "${multibooting}" == "y" && "${espfs}" != "vfat" ]]; then
|
|
if mkfs.fat -F 32 -n ESP "${esp_dev}" > "${void}" 2> "${log}" ; then
|
|
mount --mkdir "${esp_dev}" "${esp_mount}" > "${void}" 2> "${log}" || err_abort
|
|
sleep 0.2
|
|
NC "\n==> [${green}/ESP OK${nc}]"
|
|
else
|
|
umount_manual
|
|
until form_esp; do : ; done
|
|
until mount_mnt; do : ; done
|
|
until mount_esp; do : ; done
|
|
fi
|
|
fi
|
|
sleep 0.2
|
|
if [[ "${xbootloader}" == "yes" ]]; then
|
|
if mkfs.fat -F 32 -n XBOOTLDR "${xboot_dev}" > "${void}" 2> "${log}" ; then
|
|
mount --mkdir "${xboot_dev}" /mnt/boot > "${void}" 2> "${log}" || err_abort
|
|
sleep 0.2
|
|
NC "\n==> [${green}/XBOOTLDR OK${nc}]"
|
|
else
|
|
umount_manual
|
|
until form_xboot; do : ; done
|
|
until mount_mnt; do : ; done
|
|
until mount_esp; do : ; done
|
|
until mount_xboot; do : ; done
|
|
fi
|
|
fi
|
|
sleep 0.2
|
|
if [[ "${fs}" == "1" && -e "${home_dev}" && "${sep_home}" == "y" ]]; then
|
|
if [[ "${smartpart}" == "y" ]]; then
|
|
homeform="y"
|
|
elif [[ "${preset}" =~ ^(3|4)$ ]]; then
|
|
homeform="y"
|
|
elif [[ "${hometype}" == "1" ]]; then
|
|
homeform="y"
|
|
elif [[ "${hometype}" == "2" ]]; then
|
|
homeform="n"
|
|
fi
|
|
if [[ "${homeform}" == "y" ]]; then
|
|
if mkfs.ext4 -F -L Home "${home_dev}" > "${void}" 2> "${log}" ; then
|
|
tune2fs -O fast_commit "${home_dev}" > "${void}" 2> "${log}" || err_abort
|
|
mount --mkdir "${home_dev}" /mnt/home > "${void}" 2> "${log}" || err_abort
|
|
sleep 0.2
|
|
NC "\n==> [${green}/Home OK${nc}]"
|
|
else
|
|
umount_manual
|
|
until manual_part; do : ; done
|
|
until form_home; do : ; done
|
|
until mount_mnt; do : ; done
|
|
until mount_esp; do : ; done
|
|
if [[ "${xbootloader}" == "yes" ]]; then
|
|
until mount_xboot; do : ; done
|
|
fi
|
|
until mount_home; do : ; done
|
|
fi
|
|
elif [[ "${homeform}" == "n" ]]; then
|
|
mount --mkdir "${home_dev}" /mnt/home > "${void}" 2> "${log}" || err_abort
|
|
sleep 0.2
|
|
NC "\n==> [${green}Unformatted /Home Mounted OK${nc}]"
|
|
fi
|
|
fi
|
|
blkid > "${void}" 2> "${log}"
|
|
keypress
|
|
}
|
|
manual_mode() {
|
|
volumes="$(fdisk -l | grep '^/dev' | cat --number)"
|
|
if [[ "${multibooting}" == "no" ]]; then
|
|
until form_esp; do : ; done
|
|
fi
|
|
if [[ "${xbootloader}" == "yes" ]]; then
|
|
until form_xboot; do : ; done
|
|
fi
|
|
until form_root; do : ; done
|
|
if [[ "${sep_home}" == "y" && "${hometype}" == "1" ]]; then
|
|
until form_home; do : ; done
|
|
fi
|
|
until mount_mnt; do : ; done
|
|
until mount_esp; do : ; done
|
|
if [[ "${xbootloader}" == "yes" ]]; then
|
|
until mount_xboot; do : ; done
|
|
fi
|
|
if [[ "${sep_home}" == "y" ]]; then
|
|
until mount_home; do : ; done
|
|
fi
|
|
}
|
|
form_esp() {
|
|
title "Format EFI System Partition"
|
|
form_esp_nmbr=" "
|
|
while [[ -n "${form_esp_nmbr}" ]]; do
|
|
ask "Select an EFI System Partition to format as ${nc}vfat"
|
|
NC "\n\n\n${volumes}"
|
|
get "Enter a partition number"
|
|
read -r -p "==> " form_esp_nmbr
|
|
if [[ -n "${form_esp_nmbr}" ]]; then
|
|
esppart="$(echo "${volumes}" | awk "\$1 == ${form_esp_nmbr} {print \$2}")"
|
|
manespfs="$(lsblk -dno FSTYPE "${esppart}" 2> "${void}")"
|
|
if [[ -e "${esppart}" ]]; then
|
|
if [[ "${multibooting}" == "n" ]]; then
|
|
if mkfs.fat -F 32 -n ESP "${esppart}" > "${void}" 2> "${log}" ; then
|
|
local prompt="Format & Label /ESP"
|
|
ok
|
|
return 0
|
|
else
|
|
do_umount
|
|
until manual_part; do : ; done
|
|
until form_esp; do : ; done
|
|
return 0
|
|
fi
|
|
elif [[ "${multibooting}" == "y" && "${manespfs}" == "vfat" ]]; then
|
|
local prompt="Unformatted ESP"
|
|
ok
|
|
return 0
|
|
elif [[ "${multibooting}" == "y" && "${manespfs}" != "vfat" ]]; then
|
|
if mkfs.fat -F 32 -n ESP "${esppart}" > "${void}" 2> "${log}" ; then
|
|
local prompt="Format & Label /ESP"
|
|
ok
|
|
return 0
|
|
else
|
|
do_umount
|
|
until manual_part; do : ; done
|
|
until form_esp; do : ; done
|
|
return 0
|
|
fi
|
|
fi
|
|
else
|
|
invalid
|
|
return 1
|
|
fi
|
|
else
|
|
choice
|
|
return 1
|
|
fi
|
|
blkid > "${void}" 2> "${log}"
|
|
done
|
|
}
|
|
form_xboot() {
|
|
title "Format Linux Extended Boot Partition"
|
|
form_xboot_nmbr=" "
|
|
while [[ -n "${form_xboot_nmbr}" ]]; do
|
|
ask "Select a Linux Extended Boot Partition to format as ${nc}vfat"
|
|
NC "\n\n\n${volumes}"
|
|
get "Enter a partition number"
|
|
read -r -p "==> " form_xboot_nmbr
|
|
if [[ -n "${form_xboot_nmbr}" ]]; then
|
|
xbootpart="$(echo "${volumes}" | awk "\$1 == ${form_xboot_nmbr} {print \$2}")"
|
|
if [[ -e "${xbootpart}" ]]; then
|
|
if mkfs.fat -F 32 -n XBOOTLDR "${xbootpart}" > "${void}" 2> "${log}" ; then
|
|
local prompt="Format & Label /XBOOTLDR"
|
|
ok
|
|
else
|
|
do_umount
|
|
until manual_part; do : ; done
|
|
until form_xboot; do : ; done
|
|
return 0
|
|
fi
|
|
else
|
|
invalid
|
|
return 1
|
|
fi
|
|
else
|
|
choice
|
|
return 1
|
|
fi
|
|
blkid > "${void}" 2> "${log}"
|
|
done
|
|
}
|
|
form_root() {
|
|
title "Format Root Partition"
|
|
form_root_nmbr=" "
|
|
while [[ -n "${form_root_nmbr}" ]]; do
|
|
ask "Select a ${roottype} Partition to format as ${nc}${fsname}"
|
|
NC "\n\n\n${volumes}"
|
|
get "Enter a partition number"
|
|
read -r -p "==> " form_root_nmbr
|
|
if [[ -n "${form_root_nmbr}" ]]; then
|
|
rootpart="$(echo "${volumes}" | awk "\$1 == ${form_root_nmbr} {print \$2}")"
|
|
if [[ -e "${rootpart}" ]]; then
|
|
if [[ "${fs}" == "1" ]]; then
|
|
if mkfs.ext4 -F "${rootpart}" > "${void}" 2> "${log}" ; then
|
|
tune2fs -O fast_commit "${rootpart}" > "${void}" 2> "${log}" || err_abort
|
|
local prompt="Format ${roottype}"
|
|
ok
|
|
else
|
|
do_umount
|
|
until manual_part; do : ; done
|
|
until form_root; do : ; done
|
|
return 0
|
|
fi
|
|
elif [[ "${fs}" == "2" ]]; then
|
|
if mkfs.btrfs -f "${rootpart}" > "${void}" 2> "${log}" ; then
|
|
mount "${rootpart}" /mnt > "${void}" 2> "${log}" || err_abort
|
|
btrfs subvolume create /mnt/@ > "${void}" 2> "${log}" || err_abort
|
|
btrfs subvolume create /mnt/@home > "${void}" 2> "${log}" || err_abort
|
|
btrfs subvolume create /mnt/@cache > "${void}" 2> "${log}" || err_abort
|
|
btrfs subvolume create /mnt/@log > "${void}" 2> "${log}" || err_abort
|
|
btrfs subvolume create /mnt/@tmp > "${void}" 2> "${log}" || err_abort
|
|
btrfs subvolume create /mnt/@snapshots > "${void}" 2> "${log}" || err_abort
|
|
if [[ "${swapmode}" == "2" ]]; then
|
|
btrfs subvolume create /mnt/@swap > "${void}" 2> "${log}" || err_abort
|
|
fi
|
|
umount /mnt > "${void}" 2> "${log}" || err_abort
|
|
local prompt="Format ${roottype}"
|
|
ok
|
|
else
|
|
do_umount
|
|
until manual_part; do : ; done
|
|
until form_root; do : ; done
|
|
return 0
|
|
fi
|
|
fi
|
|
else
|
|
invalid
|
|
return 1
|
|
fi
|
|
echo
|
|
ask "Label the ${roottype} Partition"
|
|
get "Enter a name"
|
|
read -r -p "==> " rootpartname
|
|
if [[ -n "${rootpartname}" ]]; then
|
|
if [[ "${fs}" == "1" ]]; then
|
|
if e2label "${rootpart}" "${rootpartname}" > "${void}" 2> "${log}" ; then
|
|
local prompt="Label ${roottype}"
|
|
ok
|
|
return 0
|
|
else
|
|
err_try
|
|
return 1
|
|
fi
|
|
elif [[ "${fs}" == "2" ]]; then
|
|
mount "${rootpart}" /mnt || err_abort
|
|
btrfs filesystem label /mnt "${rootpartname}" > "${void}" 2> "${log}" || err_abort
|
|
umount /mnt || err_abort
|
|
local prompt="Label ${roottype}"
|
|
ok
|
|
return 0
|
|
fi
|
|
else
|
|
err "Please enter a name"
|
|
reload
|
|
return 1
|
|
fi
|
|
else
|
|
choice
|
|
return 1
|
|
fi
|
|
blkid > "${void}" 2> "${log}"
|
|
done
|
|
}
|
|
form_home() {
|
|
title "Format Home Partition"
|
|
form_home_nmbr=" "
|
|
while [[ -n "${form_home_nmbr}" ]]; do
|
|
ask "Select a /Home Partition to format as ${nc}Ext4"
|
|
NC "\n\n\n${volumes}"
|
|
get "Enter a partition number ${bwhite}(empty to skip and proceed)"
|
|
read -r -p "==> " form_home_nmbr
|
|
if [[ -n "${form_home_nmbr}" ]]; then
|
|
homepart="$(echo "${volumes}" | awk "\$1 == ${form_home_nmbr} {print \$2}")"
|
|
if [[ -e "${homepart}" ]]; then
|
|
if mkfs.ext4 -F "${homepart}" > "${void}" 2> "${log}" ; then
|
|
tune2fs -O fast_commit "${homepart}" > "${void}" 2> "${log}" || err_abort
|
|
local prompt="Format /Home"
|
|
ok
|
|
else
|
|
do_umount
|
|
until manual_part; do : ; done
|
|
until form_home; do : ; done
|
|
return 0
|
|
fi
|
|
else
|
|
invalid
|
|
return 1
|
|
fi
|
|
echo
|
|
ask "Label the /Home Partition"
|
|
get "Enter a name"
|
|
read -r -p "==> " homepartname
|
|
if [[ -n "${homepartname}" ]]; then
|
|
if e2label "${homepart}" "${homepartname}" > "${void}" 2> "${log}" ;then
|
|
local prompt="Label /Home"
|
|
ok
|
|
else
|
|
err_try
|
|
return 1
|
|
fi
|
|
else
|
|
err "Please enter a name"
|
|
reload
|
|
return 1
|
|
fi
|
|
else
|
|
err "${yellow}WARNING: ${nc}PARTITION HAS NOT BEEN FORMATTED"
|
|
skip
|
|
fi
|
|
blkid > "${void}" 2> "${log}"
|
|
done
|
|
}
|
|
mount_mnt() {
|
|
local prompt="Mount ${roottype}"
|
|
title "Mount Root Partition"
|
|
ask "Select a ${roottype} Partition to mount to ${nc}/mnt"
|
|
NC "\n\n\n${volumes}"
|
|
get "Enter your${nc} ${cyan}${roottype} ${blue}partition number"
|
|
read -r -p "==> " mntroot_nmbr
|
|
if [[ -n "${mntroot_nmbr}" ]]; then
|
|
rootpart="$(echo "${volumes}" | awk "\$1 == ${mntroot_nmbr} {print \$2}")"
|
|
if [[ -e "${rootpart}" ]]; then
|
|
if [[ "${fs}" == "1" ]]; then
|
|
if mount "${rootpart}" /mnt > "${void}" 2> "${log}" ; then
|
|
ok
|
|
return 0
|
|
else
|
|
do_umount
|
|
until mount_mnt; do : ; done
|
|
fi
|
|
elif [[ "${fs}" == "2" ]]; then
|
|
if mount -o "${sbvl_mnt_opts}",subvol=@ "${rootpart}" /mnt > "${void}" 2> "${log}" ; then
|
|
mount --mkdir -o "${sbvl_mnt_opts}",subvol=@home "${rootpart}" /mnt/home > "${void}" 2> "${log}" || err_abort
|
|
mount --mkdir -o "${sbvl_mnt_opts}",subvol=@cache "${rootpart}" /mnt/var/cache > "${void}" 2> "${log}" || err_abort
|
|
mount --mkdir -o "${sbvl_mnt_opts}",subvol=@log "${rootpart}" /mnt/var/log > "${void}" 2> "${log}" || err_abort
|
|
mount --mkdir -o "${sbvl_mnt_opts}",subvol=@tmp "${rootpart}" /mnt/var/tmp > "${void}" 2> "${log}" || err_abort
|
|
mount --mkdir -o "${sbvl_mnt_opts}",subvol=@snapshots "${rootpart}" /mnt/"${snapname}" > "${void}" 2> "${log}" || err_abort
|
|
if [[ "${swapmode}" == "2" ]]; then
|
|
mount --mkdir -o "${sbvl_mnt_opts}",subvol=@swap "${rootpart}" /mnt/swap > "${void}" 2> "${log}" || err_abort
|
|
fi
|
|
ok
|
|
return 0
|
|
else
|
|
do_umount
|
|
until mount_mnt; do : ; done
|
|
fi
|
|
fi
|
|
else
|
|
invalid
|
|
return 1
|
|
fi
|
|
else
|
|
choice
|
|
return 1
|
|
fi
|
|
}
|
|
mount_esp() {
|
|
local prompt="Mount ESP Partition"
|
|
title "${prompt}"
|
|
ask "Select an EFI System Partition to mount to ${nc}${esp_mount}"
|
|
NC "\n\n\n${volumes}"
|
|
get "Enter your${nc} ${cyan}/ESP ${blue}partition number"
|
|
read -r -p "==> " mntesp_nmbr
|
|
if [[ -n "${mntesp_nmbr}" ]]; then
|
|
esppart="$(echo "${volumes}" | awk "\$1 == ${mntesp_nmbr} {print \$2}")"
|
|
if [[ -e "${esppart}" ]]; then
|
|
if mount --mkdir "${esppart}" "${esp_mount}" > "${void}" 2> "${log}" ; then
|
|
ok
|
|
return 0
|
|
else
|
|
do_umount
|
|
until mount_mnt; do : ; done
|
|
until mount_esp; do : ; done
|
|
fi
|
|
else
|
|
invalid
|
|
return 1
|
|
fi
|
|
else
|
|
choice
|
|
return 1
|
|
fi
|
|
}
|
|
mount_xboot() {
|
|
local prompt="Mount XBOOTLDR Partition"
|
|
title "${prompt}"
|
|
ask "Select a Linux Extended Boot Partition to mount to ${nc}/mnt/boot"
|
|
NC "\n\n\n${volumes}"
|
|
get "Enter your${nc} ${cyan}/XBOOTLDR ${blue}partition number"
|
|
read -r -p "==> " mntxboot_nmbr
|
|
if [[ -n "${mntxboot_nmbr}" ]]; then
|
|
xbootpart="$(echo "${volumes}" | awk "\$1 == ${mntxboot_nmbr} {print \$2}")"
|
|
if [[ -e "${xbootpart}" ]]; then
|
|
if mount --mkdir "${xbootpart}" /mnt/boot > "${void}" 2> "${log}" ; then
|
|
ok
|
|
return 0
|
|
else
|
|
do_umount
|
|
until mount_mnt; do : ; done
|
|
until mount_esp; do : ; done
|
|
until mount_xboot; do : ; done
|
|
fi
|
|
else
|
|
invalid
|
|
return 1
|
|
fi
|
|
else
|
|
choice
|
|
return 1
|
|
fi
|
|
}
|
|
mount_home() {
|
|
local prompt="Mount Home Partition"
|
|
title "${prompt}"
|
|
ask "Select a /Home Partition to mount to ${nc}/mnt/home"
|
|
NC "\n\n\n${volumes}"
|
|
get "Enter your${nc} ${cyan}/Home ${blue}partition number"
|
|
read -r -p "==> " mnthome_nmbr
|
|
if [[ -n "${mnthome_nmbr}" ]]; then
|
|
homepart="$(echo "${volumes}" | awk "\$1 == ${mnthome_nmbr} {print \$2}")"
|
|
if [[ -e "${homepart}" ]]; then
|
|
if mount --mkdir "${homepart}" /mnt/home > "${void}" 2> "${log}" ; then
|
|
ok
|
|
return 0
|
|
else
|
|
do_umount
|
|
until mount_mnt; do : ; done
|
|
until mount_esp; do : ; done
|
|
until mount_xboot; do : ; done
|
|
until mount_home; do : ; done
|
|
fi
|
|
else
|
|
invalid
|
|
return 1
|
|
fi
|
|
else
|
|
choice
|
|
return 1
|
|
fi
|
|
}
|
|
confirm_status() {
|
|
local prompt="System Ready"
|
|
title "Confirm Installation Status"
|
|
get "> Proceed ?"
|
|
NC "\n * Type '${cyan}yes${nc}' to continue installation\n\n * Type '${cyan}no${nc}' to revise installation\n\n"
|
|
read -r -p "==> " agree
|
|
if [[ "${agree}" == "yes" ]]; then
|
|
ok
|
|
printf "\n\n\n"
|
|
return 0
|
|
elif [[ "${agree}" == "no" ]]; then
|
|
unmount
|
|
until revise; do : ; done
|
|
else
|
|
yes_no
|
|
return 1
|
|
fi
|
|
}
|
|
revise() {
|
|
revision="y"
|
|
gfxpkgs=()
|
|
validpkgs=()
|
|
reset=(trg="" xbootloader="" desktop="" terminal="" custompkgs="" customservices="" cust_bootopts="" REGDOM="" autoroot="" autoxboot="" autohome="" autoswap="" lowlat="" nogsp="" sanity="" partok="" preset="" set_ext_opt="" ask_param="" kill_watchdog="" sys_optm="" desk_setup="" devel="" web="" web_pkg="" web_aur="" web_slct="" oomd="" irqbalance="" thermald="" rngd="" rtkit="" tlp="" CRYPTPASS="" CRYPTPASS2="" show_extopts="" gptslct="" gptok="" gptabort="" nvidiaprop="" nowarning="" hometype="" homeform="" smartpart="" LuksParts="" nvidia_aur="" web_aur_url="" session="" alt_session="" session_support="" alt_session_pack="")
|
|
export "${reset[@]}"
|
|
instl
|
|
}
|
|
sec_erase() {
|
|
local prompt="Secure Disk Erasure"
|
|
title "${prompt}"
|
|
erase_dsk_nmbr=" "
|
|
while [[ -n "${erase_dsk_nmbr}" ]]; do
|
|
ask "Select a disk for Secure Erasure ${red}[!] (CAUTION) [!]"
|
|
inf "${nc}A reboot is mandatory and will take effect ${yellowl}immediately ${nc}when done"
|
|
NC "\n\n\n${disks}"
|
|
get "Enter a disk number ${bwhite}(empty to skip)"
|
|
read -r -p "==> " erase_dsk_nmbr
|
|
if [[ -n "${erase_dsk_nmbr}" ]]; then
|
|
erasedrive="$(echo "${disks}" | awk "\$1 == ${erase_dsk_nmbr} {print \$2}")"
|
|
if [[ -e "${erasedrive}" ]]; then
|
|
cryptsetup open --type plain -d /dev/urandom "${erasedrive}" temp || err_abort
|
|
dd if=/dev/zero of=/dev/mapper/temp status=progress bs=1M oflag=direct || err_abort
|
|
cryptsetup close temp || err_abort
|
|
local prompt="Drive ${erasedrive} Erased"
|
|
ok
|
|
local prompt="Rebooting"
|
|
ok
|
|
sleep 1
|
|
systemctl reboot
|
|
else
|
|
invalid
|
|
return 1
|
|
fi
|
|
else
|
|
skip
|
|
ok
|
|
fi
|
|
done
|
|
}
|
|
luks() {
|
|
# NOTE: LUKS Root
|
|
espfs="$(lsblk -f --noheadings "${esp_dev}" | awk "{print \$2}")"
|
|
title "LUKS Encryption"
|
|
BLUE "\n\n\n > Encrypting your ${yellowl}${LuksParts}${blue}:\n\n\n"
|
|
if echo -n "${CRYPTPASS}" | cryptsetup luksFormat --label CRYPTROOT "${root_dev}" > "${void}"; then
|
|
if [[ "${rota}" == "0" ]]; then
|
|
echo -n "${CRYPTPASS}" | cryptsetup --perf-no_read_workqueue --perf-no_write_workqueue --persistent luksOpen "${root_dev}" root || err_abort
|
|
else
|
|
echo -n "${CRYPTPASS}" | cryptsetup luksOpen "${root_dev}" root || err_abort
|
|
fi
|
|
if [[ "${fs}" == "1" ]]; then
|
|
mkfs.ext4 -F -L Root /dev/mapper/root > "${void}" 2> "${log}" || err_abort
|
|
tune2fs -O fast_commit /dev/mapper/root > "${void}" 2> "${log}" || err_abort
|
|
mount /dev/mapper/root /mnt > "${void}" 2> "${log}" || err_abort
|
|
sleep 0.2
|
|
NC "\n==> [${green}Encrypted /Root OK${nc}]"
|
|
luks_root="ok"
|
|
elif [[ "${fs}" == "2" ]]; then
|
|
mkfs.btrfs -f -L Root /dev/mapper/root > "${void}" 2> "${log}" || err_abort
|
|
mount /dev/mapper/root /mnt > "${void}" 2> "${log}" || err_abort
|
|
btrfs subvolume create /mnt/@ > "${void}" 2> "${log}" || err_abort
|
|
btrfs subvolume create /mnt/@home > "${void}" 2> "${log}" || err_abort
|
|
btrfs subvolume create /mnt/@cache > "${void}" 2> "${log}" || err_abort
|
|
btrfs subvolume create /mnt/@log > "${void}" 2> "${log}" || err_abort
|
|
btrfs subvolume create /mnt/@tmp > "${void}" 2> "${log}" || err_abort
|
|
btrfs subvolume create /mnt/@snapshots > "${void}" 2> "${log}" || err_abort
|
|
if [[ "${swapmode}" == "2" ]]; then
|
|
btrfs subvolume create /mnt/@swap > "${void}" 2> "${log}" || err_abort
|
|
fi
|
|
umount /mnt > "${void}" 2> "${log}" || err_abort
|
|
mount -o "${sbvl_mnt_opts}",subvol=@ /dev/mapper/root /mnt > "${void}" 2> "${log}" || err_abort
|
|
mount --mkdir -o "${sbvl_mnt_opts}",subvol=@home /dev/mapper/root /mnt/home > "${void}" 2> "${log}" || err_abort
|
|
mount --mkdir -o "${sbvl_mnt_opts}",subvol=@cache /dev/mapper/root /mnt/var/cache > "${void}" 2> "${log}" || err_abort
|
|
mount --mkdir -o "${sbvl_mnt_opts}",subvol=@log /dev/mapper/root /mnt/var/log > "${void}" 2> "${log}" || err_abort
|
|
mount --mkdir -o "${sbvl_mnt_opts}",subvol=@tmp /dev/mapper/root /mnt/var/tmp > "${void}" 2> "${log}" || err_abort
|
|
mount --mkdir -o "${sbvl_mnt_opts}",subvol=@snapshots /dev/mapper/root /mnt/"${snapname}" > "${void}" 2> "${log}" || err_abort
|
|
if [[ "${swapmode}" == "2" ]]; then
|
|
mount --mkdir -o "${sbvl_mnt_opts}",subvol=@swap /dev/mapper/root /mnt/swap > "${void}" 2> "${log}" || err_abort
|
|
fi
|
|
sleep 0.2
|
|
NC "\n==> [${green}Encrypted /@ OK${nc}]"
|
|
luks_root="ok"
|
|
fi
|
|
else
|
|
printf "\n\n"
|
|
err_try
|
|
do_umount
|
|
return 1
|
|
fi
|
|
# NOTE: LUKS Swap
|
|
if [[ -e "${swap_dev}" && "${swapmode}" == "1" ]]; then
|
|
printf "\n\n"
|
|
if echo -n "${CRYPTPASS}" | cryptsetup luksFormat --label CRYPTSWAP "${swap_dev}" > "${void}"; then
|
|
if [[ "${rota}" == "0" ]]; then
|
|
echo -n "${CRYPTPASS}" | cryptsetup --perf-no_read_workqueue --perf-no_write_workqueue --persistent luksOpen "${swap_dev}" swap || err_abort
|
|
else
|
|
echo -n "${CRYPTPASS}" | cryptsetup luksOpen "${swap_dev}" swap || err_abort
|
|
fi
|
|
mkswap /dev/mapper/swap > "${void}" 2> "${log}" || err_abort
|
|
sleep 0.2
|
|
NC "\n==> [${green}Encrypted /Swap OK${nc}]"
|
|
luks_swap="ok"
|
|
else
|
|
printf "\n\n"
|
|
err_try
|
|
do_umount
|
|
return 1
|
|
fi
|
|
fi
|
|
# NOTE: LUKS Home
|
|
if [[ "${sep_home}" == "y" && "${hometype}" == "1" ]]; then
|
|
printf "\n\n"
|
|
if echo -n "${CRYPTPASS}" | cryptsetup luksFormat --label CRYPTHOME "${home_dev}" > "${void}"; then
|
|
if [[ "${rota}" == "0" ]]; then
|
|
echo -n "${CRYPTPASS}" | cryptsetup --perf-no_read_workqueue --perf-no_write_workqueue --persistent luksOpen "${home_dev}" home || err_abort
|
|
else
|
|
echo -n "${CRYPTPASS}" | cryptsetup luksOpen "${home_dev}" home || err_abort
|
|
fi
|
|
mkfs.ext4 -F -L Home /dev/mapper/home > "${void}" 2> "${log}" || err_abort
|
|
tune2fs -O fast_commit /dev/mapper/home > "${void}" 2> "${log}" || err_abort
|
|
mount --mkdir /dev/mapper/home /mnt/home > "${void}" 2> "${log}" || err_abort
|
|
sleep 0.2
|
|
NC "\n==> [${green}Encrypted /Home OK${nc}]\n"
|
|
luks_home="ok"
|
|
else
|
|
printf "\n\n"
|
|
err_try
|
|
do_umount
|
|
return 1
|
|
fi
|
|
elif [[ "${sep_home}" == "y" && "${hometype}" == "2" ]]; then
|
|
ack "An existing /Home partition has been detected and will be utilized in this installation"
|
|
keypress
|
|
mount --mkdir "${home_dev}" /mnt/home > "${void}" 2> "${log}" || err_abort
|
|
sleep 0.2
|
|
NC "\n==> [${green}Unformatted /Home Mounted OK${nc}]\n"
|
|
fi
|
|
# NOTE: Unencrypted ESP
|
|
if [[ "${multibooting}" == "n" ]]; then
|
|
if mkfs.fat -F 32 -n ESP "${esp_dev}" > "${void}" 2> "${log}" ; then
|
|
mount --mkdir "${esp_dev}" "${esp_mount}" > "${void}" 2> "${log}" || err_abort
|
|
local prompt="/ESP"
|
|
ok
|
|
echo
|
|
else
|
|
do_umount
|
|
until luks; do : ; done
|
|
fi
|
|
elif [[ "${multibooting}" == "y" && "${espfs}" == "vfat" ]]; then
|
|
if mount --mkdir "${esp_dev}" "${esp_mount}" > "${void}" 2> "${log}" ; then
|
|
local prompt="Unformatted /ESP Mounted"
|
|
ok
|
|
echo
|
|
else
|
|
printf "\n\n"
|
|
err_try
|
|
do_umount
|
|
return 1
|
|
fi
|
|
elif [[ "${multibooting}" == "y" && "${espfs}" != "vfat" ]]; then
|
|
if mkfs.fat -F 32 -n ESP "${esp_dev}" > "${void}" 2> "${log}" ; then
|
|
mount --mkdir "${esp_dev}" "${esp_mount}" > "${void}" 2> "${log}" || err_abort
|
|
local prompt="/ESP"
|
|
ok
|
|
echo
|
|
else
|
|
do_umount
|
|
until luks; do : ; done
|
|
fi
|
|
fi
|
|
# NOTE: XBOOTLDR
|
|
if [[ "${xbootloader}" == "yes" ]] ; then
|
|
if mkfs.fat -F 32 -n XBOOTLDR "${xboot_dev}" > "${void}" 2> "${log}" ; then
|
|
mount --mkdir "${xboot_dev}" /mnt/boot > "${void}" 2> "${log}" || err_abort
|
|
sleep 0.2
|
|
NC "\n==> [${green}/XBOOTLDR OK${nc}]\n"
|
|
else
|
|
printf "\n\n"
|
|
err_try
|
|
do_umount
|
|
return 1
|
|
fi
|
|
fi
|
|
sleep 0.2
|
|
NC "\n==> [${green}Encryption Completed OK${nc}]"
|
|
luks_encrypt="ok"
|
|
local prompt="Filesystems"
|
|
ok
|
|
keypress
|
|
blkid > "${void}" 2> "${log}"
|
|
filesystem_overview
|
|
}
|
|
opt_pcmn() {
|
|
title "Pacman Optimization"
|
|
ask "Select a Country for your Arch Mirrors"
|
|
ack "[Enter ${nc}'l' ${yellow}to list Countries, then ${nc}'enter' ${yellow}to search or ${nc}'q' ${yellow}to quit]"
|
|
get "Enter country name or country code ${bwhite}(Empty for Defaults)"
|
|
read -r -p "==> " COUNTRY
|
|
COUNTRY="${COUNTRY^^}"
|
|
if [[ -z "${COUNTRY}" ]] ; then
|
|
local prompt="Default Mirrors"
|
|
ok
|
|
elif [[ "${COUNTRY}" == "l" ]]; then
|
|
reflector --list-countries | less
|
|
return 1
|
|
elif [[ -n "${COUNTRY}" ]]; then
|
|
printf "\n\n"
|
|
if reflector --verbose -c "${COUNTRY}" -l 10 -p https -f 10 --sort rate --save /etc/pacman.d/mirrorlist ; then
|
|
local prompt="${COUNTRY}'s Mirrors"
|
|
ok
|
|
else
|
|
err_try
|
|
return 1
|
|
fi
|
|
fi
|
|
ask "Enable Arch's 'Multilib' repository in the installed system ? [y/N]"
|
|
get "Enter [y/N]"
|
|
read -r -p "==> " multilib
|
|
multilib="${multilib:-n}"
|
|
multilib="${multilib,,}"
|
|
if [[ "${multilib}" == "y" ]]; then
|
|
local prompt="Multilib repository"
|
|
ok
|
|
elif [[ "${multilib}" == "n" ]]; then
|
|
skip
|
|
else
|
|
y_n
|
|
return 1
|
|
fi
|
|
local prompt="Pacman Optimization"
|
|
ok
|
|
}
|
|
pkg_collection() {
|
|
gfxpkgs_set
|
|
if [[ "${bootloader}" == "2" ]]; then
|
|
[[ "${fs}" == "1" ]] && bootldr_pkgs="grub os-prober"
|
|
[[ "${fs}" == "2" ]] && bootldr_pkgs="grub-btrfs inotify-tools os-prober"
|
|
fi
|
|
basepkgs=(base efibootmgr nano networkmanager pkgstats sudo vim "${fstools}" "${kernel}" "${microcode}" "${shell_pkgs}")
|
|
[[ -n "${shell}" ]] && basepkgs+=("${shell}")
|
|
[[ -n "${nrg_plc}" ]] && basepkgs+=("${nrg_plc}")
|
|
[[ -n "${bootldr_pkgs}" ]] && basepkgs+=("${bootldr_pkgs}")
|
|
[[ -n "${ukify}" ]] && basepkgs+=("${ukify}")
|
|
[[ -n "${zram}" ]] && basepkgs+=("${zram}")
|
|
[[ -n "${gfxpkgs[*]}" ]] && basepkgs+=("${gfxpkgs[*]}")
|
|
[[ -n "${devel}" ]] && basepkgs+=("${devel}")
|
|
[[ -n "${wireless_reg}" ]] && basepkgs+=("${wireless_reg}")
|
|
[[ -n "${print_pkgs}" ]] && basepkgs+=("${print_pkgs}")
|
|
[[ -n "${web_pkg}" ]] && basepkgs+=("${web_pkg}")
|
|
[[ "${vendor}" == "Virtual Machine" ]] && basepkgs+=("${vmpkgs}")
|
|
[[ "${vendor}" != "Virtual Machine" ]] && basepkgs+=(alsa-firmware linux-firmware sof-firmware)
|
|
[[ "${terminal}" == "y" ]] && basepkgs+=(gnome-terminal)
|
|
[[ "${nvidiaprop}" == "y" ]] && basepkgs+=("${kernel}-headers")
|
|
[[ "${session_support}" == "y" ]] && basepkgs+=("${alt_session_pack}")
|
|
[[ ! "${desktop}" =~ ^(11|12)$ ]] && basepkgs+=(7zip alsa-plugins alsa-utils bluez bluez-hid2hci bluez-obex bluez-utils exfatprogs git glibc-locales gst-libav gst-plugin-libcamera gst-plugin-pipewire gst-plugins-bad gst-plugins-good gst-plugins-ugly libfido2 man-db man-pages mesa-utils nano-syntax-highlighting pacman-contrib pipewire-alsa pipewire-libcamera pipewire-onnx pipewire-pulse pipewire-zeroconf reflector usb_modeswitch xdg-user-dirs)
|
|
case "${desktop}" in
|
|
1) # Plasma Desktop:
|
|
deskpkgs="${basepkgs[*]} dolphin-plugins konsole plasma qt6-multimedia-gstreamer"
|
|
displaymanager="plasmalogin" ;;
|
|
2) # Plasma Lite Desktop:
|
|
deskpkgs="${basepkgs[*]} ark bluedevil breeze-gtk colord-kde dolphin-plugins flatpak-kcm freerdp kate kcalc kclock kde-gtk-config kde-inotify-survey kdegraphics-mobipocket kdegraphics-thumbnailers kdenetwork-filesharing kdeplasma-addons kdf kdialog keditbookmarks kimageformats kio-admin kio-gdrive kio-zeroconf konsole krdc krfb kscreen kwayland-integration kwrited okular purpose ocean-sound-theme packagekit-qt6 partitionmanager plasma5-integration plasma-browser-integration plasma-desktop plasma-disks plasma-firewall plasma-keyboard plasma-login-manager plasma-nm plasma-pa plasma-systemmonitor plasma-wayland-protocols spectacle appmenu-gtk-module arj dosfstools ffmpegthumbs icoutils kvantum libappimage libappindicator lrzip lzop ntfs-3g power-profiles-daemon qrca qt5-xmlpatterns qt6-connectivity qt6-multimedia-gstreamer unarchiver unrar xdg-desktop-portal-gtk"
|
|
displaymanager="plasmalogin" ;;
|
|
3) # Gnome Desktop:
|
|
deskpkgs="${basepkgs[*]} gnome"
|
|
displaymanager="gdm" ;;
|
|
4) # Gnome Lite Desktop:
|
|
deskpkgs="${basepkgs[*]} dconf-editor file-roller gdm gnome-browser-connector gnome-calculator gnome-clocks gnome-console gnome-control-center gnome-disk-utility gnome-keyring gnome-menus gnome-shell-extensions gnome-system-monitor gnome-text-editor gnome-tweaks gnome-user-share gvfs gvfs-afc gvfs-mtp gvfs-smb loupe papers sushi dosfstools glib2-devel gparted ntfs-3g power-profiles-daemon unrar unzip xorg-xhost zip"
|
|
displaymanager="gdm" ;;
|
|
5) # Xfce Desktop:
|
|
deskpkgs="${basepkgs[*]} blueman catfish ffmpegthumbnailer gvfs gvfs-afc gvfs-mtp gvfs-smb libgsf libopenraw lightdm-gtk-greeter lightdm-gtk-greeter-settings mousepad mugshot network-manager-applet pavucontrol poppler-glib ristretto thunar-archive-plugin thunar-media-tags-plugin thunar-shares-plugin xfce4 xfce4-artwork xfce4-battery-plugin xfce4-clipman-plugin xfce4-datetime-plugin xfce4-indicator-plugin xfce4-mount-plugin xfce4-notifyd xfce4-power-manager xfce4-pulseaudio-plugin xfce4-screensaver xfce4-screenshooter xfce4-taskmanager xfce4-whiskermenu-plugin xfce4-power-manager xiccd"
|
|
displaymanager="lightdm" ;;
|
|
6) # Cinnamon Desktop:
|
|
deskpkgs="${basepkgs[*]} blueman cinnamon cinnamon-translations ffmpegthumbnailer gnome-color-manager gnome-keyring gnome-screenshot lightdm-slick-greeter touchegg wget xed xreader"
|
|
displaymanager="lightdm" ;;
|
|
7) # Deepin Desktop:
|
|
deskpkgs="${basepkgs[*]} adobe-source-han-sans-otc-fonts deepin deepin-calculator deepin-camera deepin-clipboard deepin-community-wallpapers deepin-compressor deepin-device-formatter deepin-editor deepin-font-manager deepin-grand-search deepin-kwin deepin-movie deepin-printer deepin-screensaver deepin-screensaver-pp deepin-screen-recorder deepin-shortcut-viewer deepin-terminal iw proxychains-ng qt6-multimedia-gstreamer redshift zssh"
|
|
displaymanager="lightdm" ;;
|
|
8) # Budgie Desktop:
|
|
deskpkgs="${basepkgs[*]} blueman budgie gnome-user-share lightdm-gtk-greeter lightdm-gtk-greeter-settings nemo network-manager-applet openssh power-profiles-daemon rygel xdg-user-dirs"
|
|
displaymanager="lightdm" ;;
|
|
9) # Lxqt Desktop:
|
|
deskpkgs="${basepkgs[*]} blueman breeze-icons gvfs gvfs-mtp kimageformats libarchive libstatgrab libsysstat lxqt network-manager-applet oxygen-icons python-pyxdg qt6-imageformats qt6-multimedia-gstreamer sddm xorg-xrdb xscreensaver xsettingsd"
|
|
displaymanager="sddm" ;;
|
|
10) # Mate Desktop:
|
|
deskpkgs="${basepkgs[*]} atril blueman caja-actions caja-audio-video-properties caja-open-terminal caja-sendto caja-share caja-wallpaper cpio engrampa eom gnome-keyring lightdm-gtk-greeter lightdm-gtk-greeter-settings mate mate-applets mate-calc mate-icon-theme-faenza mate-media mate-netbook mate-power-manager mate-screensaver mate-system-monitor mate-terminal mate-user-share mate-utils mozo network-manager-applet pluma python-gobject unace unrar webp-pixbuf-loader xdg-user-dirs-gtk"
|
|
displaymanager="lightdm" ;;
|
|
11) # Base System:
|
|
deskpkgs="${basepkgs[*]}" ;;
|
|
12) # Custom System:
|
|
custarray=(base sudo "${custompkgs}" "${fstools}" "${kernel}" "${microcode}")
|
|
[[ -n "${shell}" ]] && custarray+=("${shell}")
|
|
[[ -n "${bootldr_pkgs}" ]] && custarray+=("${bootldr_pkgs}")
|
|
[[ -n "${ukify}" ]] && custarray+=("${ukify}")
|
|
[[ -n "${zram}" ]] && custarray+=("${zram}")
|
|
[[ -n "${gfxpkgs[*]}" ]] && custarray+=("${gfxpkgs[*]}")
|
|
[[ -n "${wireless_reg}" ]] && custarray+=("${wireless_reg}")
|
|
[[ -n "${print_pkgs}" ]] && custarray+=("${print_pkgs}")
|
|
[[ "${vendor}" == "Virtual Machine" ]] && custarray+=("${vmpkgs}")
|
|
[[ "${vendor}" != "Virtual Machine" ]] && custarray+=(linux-firmware)
|
|
[[ "${nvidiaprop}" == "y" ]] && custarray+=("${kernel}-headers")
|
|
deskpkgs="${custarray[*]}" ;;
|
|
13) # Cosmic Desktop:
|
|
deskpkgs="${basepkgs[*]} cosmic dconf gnome-keyring gvfs gvfs-dnssd gvfs-nfs gvfs-smb packagekit power-profiles-daemon pulseaudio-alsa"
|
|
displaymanager="cosmic-greeter" ;;
|
|
14) # Pantheon Desktop:
|
|
deskpkgs="${basepkgs[*]} pantheon pantheon-print sound-theme-elementary"
|
|
displaymanager="lightdm" ;;
|
|
esac
|
|
}
|
|
pkg_validation() {
|
|
local prompt="Arch Packages Validation"
|
|
local stage_prompt="Arch Packages Validation"
|
|
sleep 0.2
|
|
YELLOWL "\n ------------------------------------------\n ### ${bwhite}Validating Installation Packages ${yellowl}###\n ------------------------------------------\n\n"
|
|
validpkgs+=("${deskpkgs}")
|
|
echo "${validpkgs[*]}"
|
|
keypress
|
|
valids="${validpkgs[*]}"
|
|
printf "\n\n"
|
|
if pacman -Syy > "${void}" 2>&1 2> "${log}" && pacman -Spd ${valids} > "${void}" 2>&1 2> "${log}"; then
|
|
ok
|
|
if [[ -n "${web_aur}" ]]; then
|
|
local prompt="${web_name} Package Validation"
|
|
pacman -S --noconfirm wget > "${void}"
|
|
if wget -4q --spider "${web_aur_url}" 2> "${log}"; then
|
|
ok
|
|
else
|
|
err_try
|
|
return 1
|
|
fi
|
|
fi
|
|
if [[ -n "${nvidia_aur}" ]]; then
|
|
local prompt="Nvidia 580xx Drivers Package Validation"
|
|
if [[ ! -e /usr/bin/wget ]]; then
|
|
pacman -S --noconfirm wget > "${void}"
|
|
fi
|
|
if wget -4q --spider https://aur.archlinux.org/cgit/aur.git/snapshot/nvidia-580xx-utils.tar.gz 2> "${log}" &&
|
|
wget -4q --spider https://aur.archlinux.org/cgit/aur.git/snapshot/nvidia-580xx-settings.tar.gz 2> "${log}"; then
|
|
ok
|
|
else
|
|
err_try
|
|
return 1
|
|
fi
|
|
fi
|
|
else
|
|
err_try
|
|
return 1
|
|
fi
|
|
if [[ "${encrypt}" == "no" ]]; then
|
|
until confirm_status; do : ; done
|
|
elif [[ "${encrypt}" == "yes" ]]; then
|
|
keypress
|
|
fi
|
|
}
|
|
pacstrap_system() {
|
|
local prompt="Pacstrap System"
|
|
title "${prompt}"
|
|
installing
|
|
pkg_collection
|
|
pkg_validation
|
|
if pacstrap -K /mnt ${deskpkgs} 2> "${log}" ; then
|
|
if [[ -n "${nvidia_aur}" ]]; then
|
|
YELLOWL "\n\n\n ---------------------------------------\n ### ${nc}Building ${bwhite}Nvidia-580xx ${nc}Drivers ${yellowl}###\n ---------------------------------------${nc}\n ... Please Wait ...\n\n\n"
|
|
if [[ "${dev}" != "y" ]]; then
|
|
local stage_prompt="Base-devel Package Installation"
|
|
if arch-chroot /mnt <<-BASE_DEVEL > "${void}" 2>&1 2> "${log}" ; then
|
|
pacman -S --noconfirm base-devel
|
|
BASE_DEVEL
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
fi
|
|
if [[ "${desktop}" =~ ^(11|12)$ ]]; then
|
|
local stage_prompt="Git Package Installation"
|
|
if arch-chroot /mnt <<-GIT > "${void}" 2>&1 2> "${log}" ; then
|
|
pacman -S --noconfirm git
|
|
GIT
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
fi
|
|
local stage_prompt="AUR Nvidia Packages Installation"
|
|
if arch-chroot /mnt <<-AUR_NVIDIA_PKGS > "${void}" 2>&1 2> "${log}" ; then
|
|
sed -i 's|if (( EUID == 0 )); then|if (( EUID != 0 )); then|g' /usr/bin/makepkg
|
|
git clone --branch nvidia-580xx-utils --single-branch https://github.com/archlinux/aur.git nvidia-580xx-utils && cd nvidia-580xx-utils && makepkg -s --noconfirm && sudo pacman -U --noconfirm *x86_64.pkg.tar.zst && cd .. && rm -rf nvidia-580xx-utils
|
|
git clone --branch nvidia-580xx-settings --single-branch https://github.com/archlinux/aur.git nvidia-580xx-settings && cd nvidia-580xx-settings && makepkg -s --noconfirm && sudo pacman -U --noconfirm *x86_64.pkg.tar.zst && cd .. && rm -rf nvidia-580xx-settings
|
|
sed -i 's|if (( EUID != 0 )); then|if (( EUID == 0 )); then|g' /usr/bin/makepkg
|
|
AUR_NVIDIA_PKGS
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
fi
|
|
ok
|
|
else
|
|
local stage_prompt="Pacstrap System"
|
|
stage_fail
|
|
fi
|
|
if [[ "${fs}" == "2" ]]; then
|
|
local prompt="Fstab"
|
|
local stage_prompt="Fstab"
|
|
genfstab -t PARTUUID /mnt >> /mnt/etc/fstab 2> "${log}" || stage_fail
|
|
arch-chroot /mnt <<-FSTAB_SBVL_MNT_OPTS > "${void}" 2>&1 2> "${log}" || stage_fail
|
|
sed -i 's/^rw.*/${sbvl_mnt_opts}/' /etc/fstab
|
|
FSTAB_SBVL_MNT_OPTS
|
|
ok
|
|
fi
|
|
if [[ "${swapmode}" != "2" ]]; then
|
|
printf "\n\n"
|
|
fi
|
|
}
|
|
swapfile() {
|
|
local prompt="Swapfile Setup"
|
|
local stage_prompt="Swapfile Setup"
|
|
title "${prompt}"
|
|
if arch-chroot /mnt <<-SWAPFILE > "${void}" 2>&1 2> "${log}" ; then
|
|
mkswap -U clear --size ${swapsize}G --file /swapfile
|
|
SWAPFILE
|
|
cat >> /mnt/etc/fstab <<-FSTAB || err_abort
|
|
/swapfile none swap defaults 0 0
|
|
FSTAB
|
|
ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
}
|
|
swapfile_btrfs() {
|
|
local prompt="Btrfs Swapfile Setup"
|
|
local stage_prompt="Btrfs Swapfile Setup"
|
|
title "${prompt}"
|
|
if arch-chroot /mnt <<-SWAPFILE_BTRFS > "${void}" 2>&1 2> "${log}" ; then
|
|
btrfs filesystem mkswapfile --size ${swapsize}g --uuid clear /swap/swapfile
|
|
SWAPFILE_BTRFS
|
|
cat >> /mnt/etc/fstab <<-FSTAB || err_abort
|
|
/swap/swapfile none swap defaults 0 0
|
|
FSTAB
|
|
ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
}
|
|
set_wireless_regdom() {
|
|
local prompt="Wireless Regulatory Domain"
|
|
local stage_prompt="Wireless Regulatory Domain"
|
|
title "Setting Up Wireless Regulatory Domain"
|
|
if sed -i "/^#WIRELESS_REGDOM=\"${REGDOM}\"/s/^#//" /mnt/etc/conf.d/wireless-regdom ; then
|
|
ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
}
|
|
main_chroot() {
|
|
local stage_prompt="Base System Configuration"
|
|
if arch-chroot /mnt <<-CONF > "${void}" 2>&1 2> "${log}" ; then
|
|
sed -i "/^#${SETLOCALE}/s/^#//" /etc/locale.gen
|
|
locale-gen
|
|
echo LANG=${SETLOCALE} > /etc/locale.conf
|
|
export LANG=${SETLOCALE}
|
|
echo KEYMAP=${SETKBD} > /etc/vconsole.conf
|
|
cat <<-MKINITCPIO > /etc/mkinitcpio.conf.d/mkinitcpiod.conf
|
|
${mkinitcpio_mods}
|
|
${mkinitcpio_bins}
|
|
${mkinitcpio_hooks}
|
|
MKINITCPIO
|
|
mkinitcpio -P
|
|
ln -sf /usr/share/zoneinfo/$(curl -s http://ip-api.com/line?fields=timezone) /etc/localtime
|
|
hwclock --systohc
|
|
echo ${HOSTNAME} > /etc/hostname
|
|
cat <<-HOSTS > /etc/hosts
|
|
127.0.0.1 localhost
|
|
::1 localhost
|
|
127.0.1.1 ${HOSTNAME}.localdomain ${HOSTNAME}
|
|
HOSTS
|
|
echo root:${ROOTPASSWD2} | chpasswd
|
|
chsh -s /bin/${shellname}
|
|
useradd -m -G wheel -s /bin/${shellname} ${USERNAME}
|
|
echo ${USERNAME}:${USERPASSWD2} | chpasswd
|
|
echo "%wheel ALL=(ALL) ALL" | tee /etc/sudoers.d/sudoersd
|
|
visudo -c /etc/sudoers.d/sudoersd
|
|
CONF
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
}
|
|
btldrcfg() {
|
|
if [[ "${bootloader}" == "1" ]]; then
|
|
local stage_prompt="Systemd-boot Configuration"
|
|
if [[ "${xbootloader}" == "no" ]]; then
|
|
if arch-chroot -S /mnt <<-SDBOOT_INSTL > "${void}" 2>&1 2> "${log}" ; then
|
|
bootctl install
|
|
cat <<-LOADER_CFG > ${btldr_esp_mount}/loader/loader.conf
|
|
timeout 3
|
|
console-mode auto
|
|
editor no
|
|
LOADER_CFG
|
|
systemctl enable systemd-boot-update
|
|
SDBOOT_INSTL
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
elif [[ "${xbootloader}" == "yes" ]]; then
|
|
if arch-chroot -S /mnt <<-SDBOOT_XBOOTLDR_INSTL > "${void}" 2>&1 2> "${log}" ; then
|
|
bootctl --esp-path=/efi --boot-path=/boot install
|
|
cat <<-LOADER_CFG > ${btldr_esp_mount}/loader/loader.conf
|
|
default arch.conf
|
|
timeout 3
|
|
console-mode auto
|
|
editor no
|
|
LOADER_CFG
|
|
cat <<-ENTRY_CFG > /boot/loader/entries/arch.conf
|
|
title Arch Linux
|
|
linux /vmlinuz-${kernel}
|
|
initrd /initramfs-${kernel}.img
|
|
options rw ${boot_opts[*]}
|
|
ENTRY_CFG
|
|
systemctl enable systemd-boot-update
|
|
SDBOOT_XBOOTLDR_INSTL
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
fi
|
|
elif [[ "${bootloader}" == "2" ]]; then
|
|
local stage_prompt="Grub Configuration"
|
|
if arch-chroot /mnt <<-GRUB_CONF > "${void}" 2>&1 2> "${log}" ; then
|
|
cp /etc/default/grub /etc/default/grub.bak
|
|
cat <<-CFG > /etc/default/grub
|
|
GRUB_DEFAULT=0
|
|
GRUB_TIMEOUT=5
|
|
GRUB_DISTRIBUTOR="Arch"
|
|
GRUB_CMDLINE_LINUX_DEFAULT="${boot_opts[*]}"
|
|
GRUB_CMDLINE_LINUX=""
|
|
GRUB_PRELOAD_MODULES="part_gpt part_msdos"
|
|
GRUB_TIMEOUT_STYLE=menu
|
|
GRUB_TERMINAL_INPUT=console
|
|
GRUB_GFXMODE=auto
|
|
GRUB_GFXPAYLOAD_LINUX=keep
|
|
GRUB_DISABLE_RECOVERY=true
|
|
GRUB_DISABLE_OS_PROBER=false
|
|
#GRUB_TERMINAL_OUTPUT=console
|
|
CFG
|
|
GRUB_CONF
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
local stage_prompt="Grub Installation"
|
|
if [[ "${sb_sign}" == "y" && "${path}" == "1" ]]; then
|
|
if arch-chroot /mnt <<-SB_GRUB_INSTL > "${void}" 2>&1 2> "${log}" ; then
|
|
grub-install --target=${uefimode} --efi-directory=${btldr_esp_mount} --bootloader-id=GRUB --modules="tpm" --disable-shim-lock --recheck
|
|
sed -i 's/SecureBoot/SecureB00t/' ${btldr_esp_mount}/EFI/GRUB/grubx${bitness}.efi
|
|
grub-mkconfig -o /boot/grub/grub.cfg
|
|
SB_GRUB_INSTL
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
elif [[ "${sb_sign}" == "y" && "${path}" == "2" ]]; then
|
|
if arch-chroot /mnt <<-SB_GRUB_INSTL_RMV > "${void}" 2>&1 2> "${log}" ; then
|
|
grub-install --target=${uefimode} --efi-directory=${btldr_esp_mount} --bootloader-id=GRUB --removable --modules="tpm" --disable-shim-lock --recheck
|
|
sed -i 's/SecureBoot/SecureB00t/' ${btldr_esp_mount}/EFI/BOOT/${efiname}.EFI
|
|
grub-mkconfig -o /boot/grub/grub.cfg
|
|
SB_GRUB_INSTL_RMV
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
elif [[ "${sb_sign}" == "n" && "${path}" == "1" ]]; then
|
|
if arch-chroot /mnt <<-GRUB_INSTL > "${void}" 2>&1 2> "${log}" ; then
|
|
grub-install --target=${uefimode} --efi-directory=${btldr_esp_mount} --bootloader-id=GRUB --recheck
|
|
grub-mkconfig -o /boot/grub/grub.cfg
|
|
GRUB_INSTL
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
elif [[ "${sb_sign}" == "n" && "${path}" == "2" ]]; then
|
|
if arch-chroot /mnt <<-GRUB_INSTL_RMV > "${void}" 2>&1 2> "${log}" ; then
|
|
grub-install --target=${uefimode} --efi-directory=${btldr_esp_mount} --bootloader-id=GRUB --removable --recheck
|
|
grub-mkconfig -o /boot/grub/grub.cfg
|
|
GRUB_INSTL_RMV
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
fi
|
|
if [[ "${fs}" == "2" ]]; then
|
|
local stage_prompt="Grub-Btrfsd Service Activation"
|
|
if arch-chroot /mnt <<-GRUB_BTRFSD > "${void}" 2>&1 2> "${log}" ; then
|
|
systemctl enable grub-btrfsd
|
|
GRUB_BTRFSD
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
fi
|
|
if [[ "${nvidiaprop}" == "y" ]]; then
|
|
local stage_prompt="Grub/Nvidia Configuration"
|
|
if arch-chroot /mnt <<-NVIDIA_GRUB > "${void}" 2>&1 2> "${log}" ; then
|
|
sed -i "/^#GRUB_TERMINAL_OUTPUT=console/s/^#//" /etc/default/grub
|
|
grub-mkconfig -o /boot/grub/grub.cfg
|
|
NVIDIA_GRUB
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
fi
|
|
fi
|
|
}
|
|
trimcfg() {
|
|
if [[ -n "${trim}" ]]; then
|
|
local stage_prompt="Trim Service Activation"
|
|
if arch-chroot /mnt <<-TRIM > "${void}" 2>&1 2> "${log}" ; then
|
|
systemctl enable ${trim}
|
|
TRIM
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
fi
|
|
}
|
|
vm_serv() {
|
|
if [[ -n "${vm_services}" ]]; then
|
|
local stage_prompt="VM Service(s) Activation"
|
|
if arch-chroot /mnt <<-VM_SRVC > "${void}" 2>&1 2> "${log}" ; then
|
|
systemctl enable ${vm_services}
|
|
VM_SRVC
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
fi
|
|
}
|
|
zramcfg() {
|
|
if [[ -n "${zram}" ]]; then
|
|
local stage_prompt="Zram Swap Activation"
|
|
zram_service="systemd-zram-setup@zram0.service"
|
|
if arch-chroot /mnt <<-ZRAM_CONF > "${void}" 2>&1 2> "${log}" ; then
|
|
mkdir -p /etc/systemd/zram-generator.conf.d
|
|
cat <<-ZRAM_GEN > /etc/systemd/zram-generator.conf.d/zram.conf
|
|
[zram0]
|
|
zram-size = ram / 2
|
|
compression-algorithm = zstd
|
|
ZRAM_GEN
|
|
cat <<-ZRAM_VM > /etc/sysctl.d/99-vm-zram-parameters.conf
|
|
vm.swappiness = 180
|
|
vm.watermark_boost_factor = 0
|
|
vm.watermark_scale_factor = 125
|
|
vm.page-cluster = 0
|
|
ZRAM_VM
|
|
systemctl daemon-reload
|
|
systemctl start ${zram_service}
|
|
ZRAM_CONF
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
fi
|
|
}
|
|
nvidia_hook() {
|
|
if [[ "${nvidiaprop}" == "y" && -n "${nvname}" ]]; then
|
|
local stage_prompt="Nvidia Hook Creation"
|
|
if arch-chroot /mnt <<-NVIDIA_HOOK > "${void}" 2>&1 2> "${log}" ; then
|
|
mkdir -p /etc/pacman.d/hooks/
|
|
cat <<-HOOK > /etc/pacman.d/hooks/nvidia.hook
|
|
[Trigger]
|
|
Operation=Install
|
|
Operation=Upgrade
|
|
Operation=Remove
|
|
Type=Package
|
|
Target=${nvname}
|
|
Target=${kernel}
|
|
|
|
[Action]
|
|
Description=Updating NVIDIA module in initcpio
|
|
Depends=mkinitcpio
|
|
When=PostTransaction
|
|
NeedsTargets
|
|
Exec=/bin/sh -c 'while read -r trg; do case $trg in linux*) exit 0; esac; done; /usr/bin/mkinitcpio -P'
|
|
HOOK
|
|
NVIDIA_HOOK
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
fi
|
|
}
|
|
mkinitcpio_preset() {
|
|
local stage_prompt="Mkinitcpio Kernel Presets Configuration"
|
|
if [[ "${uki}" == "y" ]]; then
|
|
if [[ ! -e "${esp_mount}"/EFI/Linux ]]; then
|
|
mkdir -p "${esp_mount}"/EFI/Linux
|
|
fi
|
|
if arch-chroot /mnt <<-UKI > "${void}" 2>&1 2> "${log}" ; then
|
|
mkdir /etc/cmdline.d
|
|
echo "rw ${boot_opts[*]}" | tee /etc/cmdline.d/cmdlined.conf
|
|
cp /etc/mkinitcpio.d/${kernel}.preset /etc/mkinitcpio.d/${kernel}.preset.bak
|
|
cat <<-MKINITCPIO_PRESET > /etc/mkinitcpio.d/${kernel}.preset
|
|
# mkinitcpio preset file for the '${kernel}' package
|
|
ALL_config="/etc/mkinitcpio.conf.d/mkinitcpiod.conf"
|
|
ALL_kver="/boot/vmlinuz-${kernel}"
|
|
PRESETS=('default')
|
|
default_uki="${btldr_esp_mount}/EFI/Linux/arch-${kernel}.efi"
|
|
MKINITCPIO_PRESET
|
|
mkinitcpio -P
|
|
UKI
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
for file in /mnt/boot/*.img; do
|
|
if [ -f "$file" ]; then
|
|
rm "$file"
|
|
fi
|
|
done
|
|
elif [[ "${uki}" == "n" ]]; then
|
|
if arch-chroot /mnt <<-NO_UKI > "${void}" 2>&1 2> "${log}" ; then
|
|
cp /etc/mkinitcpio.d/${kernel}.preset /etc/mkinitcpio.d/${kernel}.preset.bak
|
|
cat <<-MKINITCPIO_PRESET > /etc/mkinitcpio.d/${kernel}.preset
|
|
# mkinitcpio preset file for the '${kernel}' package
|
|
ALL_config="/etc/mkinitcpio.conf.d/mkinitcpiod.conf"
|
|
ALL_kver="/boot/vmlinuz-${kernel}"
|
|
PRESETS=('default')
|
|
default_image="/boot/initramfs-${kernel}.img"
|
|
MKINITCPIO_PRESET
|
|
mkinitcpio -P
|
|
NO_UKI
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
fi
|
|
}
|
|
var_opts() {
|
|
if [[ "${sb_sign}" == "y" && "${setrescue}" == "y" ]]; then
|
|
local stage_prompt="Rescue Entry Creation"
|
|
if [[ "${bootloader}" == "1" && "${uki}" == "y" ]]; then
|
|
if arch-chroot /mnt <<-SDBOOT_RESCUE_ENTRY > "${void}" 2>&1 2> "${log}" ; then
|
|
echo "systemd.unit=rescue.target rw ${boot_opts[*]}" | tee /etc/cmdline.d/rescued.conf
|
|
cat <<-MKINITCPIO_PRESET > /etc/mkinitcpio.d/${kernel}.preset
|
|
# mkinitcpio preset file for the '${kernel}' package
|
|
ALL_config="/etc/mkinitcpio.conf.d/mkinitcpiod.conf"
|
|
ALL_kver="/boot/vmlinuz-${kernel}"
|
|
PRESETS=('default' 'rescue')
|
|
default_uki="${btldr_esp_mount}/EFI/Linux/arch-${kernel}.efi"
|
|
default_options="--cmdline /etc/cmdline.d/cmdlined.conf"
|
|
rescue_uki="${btldr_esp_mount}/EFI/Linux/rescue.efi"
|
|
rescue_options="--cmdline /etc/cmdline.d/rescued.conf"
|
|
MKINITCPIO_PRESET
|
|
mkinitcpio -P
|
|
SDBOOT_RESCUE_ENTRY
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
elif [[ "${bootloader}" == "1" && "${uki}" == "n" ]]; then
|
|
if arch-chroot /mnt <<-SDBOOT_XBOOTLDR_RESCUE_ENTRY > "${void}" 2>&1 2> "${log}" ; then
|
|
cat <<-XBOOTLDR_RESCUE_CONF > /boot/loader/entries/rescue.conf
|
|
title Arch Rescue
|
|
linux /vmlinuz-${kernel}
|
|
initrd /initramfs-${kernel}.img
|
|
options rw systemd.unit=rescue.target ${boot_opts[*]}
|
|
XBOOTLDR_RESCUE_CONF
|
|
SDBOOT_XBOOTLDR_RESCUE_ENTRY
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
elif [[ "${bootloader}" == "2" ]]; then
|
|
if arch-chroot /mnt <<-GRUB_RESCUE_ENTRY > "${void}" 2>&1 2> "${log}" ; then
|
|
touch /boot/grub/custom.cfg
|
|
grep -E -A 11 "'Arch Linux'" /boot/grub/grub.cfg > /boot/grub/custom.cfg
|
|
sed -i 's/Arch Linux/Rescue Environment/' /boot/grub/custom.cfg
|
|
sed -i '/vmlinuz/ s/$/ systemd.unit=rescue.target/' /boot/grub/custom.cfg
|
|
GRUB_RESCUE_ENTRY
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
fi
|
|
fi
|
|
if [[ "${multilib}" == "y" ]]; then
|
|
local stage_prompt="Multilib Configuration"
|
|
if arch-chroot /mnt <<-MULTILIB > "${void}" 2>&1 2> "${log}" ; then
|
|
sed -i "/\[multilib\]/,/Include/"'s/^#//' /etc/pacman.conf
|
|
pacman -Syy
|
|
MULTILIB
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
fi
|
|
if [[ "${CPU}" == *"GenuineIntel"* && "${kill_watchdog}" == "y" ]]; then
|
|
local stage_prompt="Intel Watchdog Configuration"
|
|
if arch-chroot /mnt <<-INTEL_WATCHDOG > "${void}" 2>&1 2> "${log}" ; then
|
|
echo "blacklist iTCO_wdt" | tee /etc/modprobe.d/blacklist.conf
|
|
INTEL_WATCHDOG
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
elif [[ "${CPU}" == *"AuthenticAMD"* && "${kill_watchdog}" == "y" ]]; then
|
|
local stage_prompt="AMD Watchdog Configuration"
|
|
if arch-chroot /mnt <<-AMD_WATCHDOG > "${void}" 2>&1 2> "${log}" ; then
|
|
echo "blacklist sp5100_tco" | tee /etc/modprobe.d/blacklist.conf
|
|
AMD_WATCHDOG
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
fi
|
|
if [[ "${oomd}" == "y" ]]; then
|
|
local stage_prompt="Systemd-oomd Service Activation"
|
|
if arch-chroot /mnt <<-OOMD > "${void}" 2>&1 2> "${log}" ; then
|
|
mkdir -p /etc/systemd/system.conf.d > "${void}" 2>&1
|
|
cat <<-OOMD_CONF > /etc/systemd/system.conf.d/00-oomd.conf
|
|
[Manager]
|
|
DefaultMemoryAccounting=yes
|
|
OOMD_CONF
|
|
systemctl enable systemd-oomd
|
|
OOMD
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
fi
|
|
if [[ "${irqbalance}" == "y" ]]; then
|
|
local stage_prompt="Irqbalance Service Activation"
|
|
if arch-chroot /mnt <<-IRQBALANCE > "${void}" 2>&1 2> "${log}" ; then
|
|
pacman -S --noconfirm irqbalance
|
|
systemctl enable irqbalance
|
|
IRQBALANCE
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
fi
|
|
if [[ "${thermald}" == "y" ]]; then
|
|
local stage_prompt="Thermald Service Activation"
|
|
if arch-chroot /mnt <<-THERMALD > "${void}" 2>&1 2> "${log}" ; then
|
|
pacman -S --noconfirm thermald
|
|
systemctl enable thermald
|
|
THERMALD
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
fi
|
|
if [[ "${rngd}" == "y" ]]; then
|
|
local stage_prompt="Rngd Service Activation"
|
|
if arch-chroot /mnt <<-RNGD > "${void}" 2>&1 2> "${log}" ; then
|
|
pacman -S --noconfirm rng-tools
|
|
systemctl enable rngd
|
|
RNGD
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
fi
|
|
if [[ "${rtkit}" == "y" ]]; then
|
|
local stage_prompt="Rtkit Service Activation"
|
|
if arch-chroot /mnt <<-RTKIT > "${void}" 2>&1 2> "${log}" ; then
|
|
pacman -S --noconfirm realtime-privileges rtkit
|
|
systemctl enable rtkit-daemon
|
|
usermod -aG realtime ${USERNAME}
|
|
RTKIT
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
fi
|
|
if [[ "${tlp}" == "y" ]]; then
|
|
local stage_prompt="Power-profiles-daemon Removal"
|
|
if [[ -e usr/lib/power-profiles-daemon ]]; then
|
|
if arch-chroot /mnt <<-PPD > "${void}" 2>&1 2> "${log}" ; then
|
|
pacman -Rns --noconfirm power-profiles-daemon
|
|
PPD
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
fi
|
|
local stage_prompt="Tlp Service Activation"
|
|
if arch-chroot /mnt <<-TLP > "${void}" 2>&1 2> "${log}" ; then
|
|
pacman -S --noconfirm tlp
|
|
systemctl enable tlp
|
|
systemctl mask systemd-rfkill.service systemd-rfkill.socket
|
|
TLP
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
fi
|
|
if [[ "${printer}" == "y" ]]; then
|
|
local stage_prompt="Print & Scan Services Activation"
|
|
if arch-chroot /mnt <<-PRINT_CONF > "${void}" 2>&1 2> "${log}" ; then
|
|
systemctl enable avahi-daemon.socket cups.socket cups-browsed ipp-usb
|
|
sed -i 's|^hosts.*|hosts: mymachines mdns_minimal resolve [!UNAVAIL=return] files myhostname dns|g' /etc/nsswitch.conf
|
|
sed -i 's/ interface = [^ ]*/ interface = all/g' /etc/ipp-usb/ipp-usb.conf
|
|
PRINT_CONF
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
fi
|
|
}
|
|
foreign() {
|
|
if [[ -n "${web_aur}" ]]; then
|
|
if [[ -z "${nvidia_aur}" ]]; then
|
|
if [[ "${dev}" != "y" ]]; then
|
|
local stage_prompt="Base-devel Package Installation"
|
|
if arch-chroot /mnt <<-BASE_DEVEL > "${void}" 2>&1 2> "${log}" ; then
|
|
pacman -S --noconfirm base-devel
|
|
BASE_DEVEL
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
fi
|
|
if [[ "${desktop}" =~ ^(11|12)$ ]]; then
|
|
local stage_prompt="Git Package Installation"
|
|
if arch-chroot /mnt <<-GIT > "${void}" 2>&1 2> "${log}" ; then
|
|
pacman -S --noconfirm git
|
|
GIT
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
fi
|
|
fi
|
|
local stage_prompt="${web_name} Package Installation"
|
|
if arch-chroot /mnt <<-AUR_WEB_PKGS > "${void}" 2>&1 2> "${log}" ; then
|
|
sed -i 's|if (( EUID == 0 )); then|if (( EUID != 0 )); then|g' /usr/bin/makepkg
|
|
git clone --branch ${web_aur} --single-branch https://github.com/archlinux/aur.git ${web_aur} && cd ${web_aur} && makepkg -s --noconfirm && sudo pacman -U --noconfirm *x86_64.pkg.tar.zst && cd .. && rm -rf ${web_aur}
|
|
sed -i 's|if (( EUID != 0 )); then|if (( EUID == 0 )); then|g' /usr/bin/makepkg
|
|
AUR_WEB_PKGS
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
fi
|
|
}
|
|
optimizations() {
|
|
if [[ "${sys_optm}" == "y" ]]; then
|
|
local stage_prompt="General System Optimizations"
|
|
if arch-chroot /mnt <<-SYS_OPTM > "${void}" 2>&1 2> "${log}" ; then
|
|
pacman -S --noconfirm ccache ntfs-3g pbzip2 pigz
|
|
sed -i 's/^#Color/Color\nILoveCandy/' /etc/pacman.conf
|
|
update-pciids
|
|
cat <<-MKINITCPIO >> /etc/mkinitcpio.conf.d/mkinitcpiod.conf
|
|
COMPRESSION="zstd"
|
|
COMPRESSION_OPTIONS=(-c -T$(nproc) --auto-threads=logical -)
|
|
MKINITCPIO
|
|
mkinitcpio -P
|
|
cat <<-MAKEPKG > /etc/makepkg.conf.d/makepkgd.conf
|
|
#!/hint/bash
|
|
CFLAGS="-march=native -O2 -pipe -fno-plt -fexceptions \
|
|
-Wp,-D_FORTIFY_SOURCE=3 -Wformat -Werror=format-security \
|
|
-fstack-clash-protection -fcf-protection \
|
|
-fno-omit-frame-pointer -mno-omit-leaf-frame-pointer"
|
|
MAKEFLAGS="-j$(nproc)"
|
|
BUILDENV=(!distcc color ccache check !sign)
|
|
OPTIONS=(strip docs !libtool !staticlibs emptydirs zipman purge !debug lto)
|
|
COMPRESSGZ=(pigz -c -f -n)
|
|
COMPRESSBZ2=(pbzip2 -c -f)
|
|
COMPRESSZST=(zstd -c -T0 --auto-threads=logical -)
|
|
MAKEPKG
|
|
cat <<-IO_SCHED > /etc/udev/rules.d/60-ioschedulers.rules
|
|
# HDD
|
|
ACTION=="add|change", KERNEL=="sd[a-z]*", ATTR{queue/rotational}=="1", ATTR{queue/scheduler}="bfq"
|
|
# SSD
|
|
ACTION=="add|change", KERNEL=="sd[a-z]*|mmcblk[0-9]*", ATTR{queue/rotational}=="0", ATTR{queue/scheduler}="bfq"
|
|
# NVMe SSD
|
|
ACTION=="add|change", KERNEL=="nvme[0-9]*", ATTR{queue/rotational}=="0", ATTR{queue/scheduler}="none"
|
|
IO_SCHED
|
|
cat <<-SYSCTL > /etc/sysctl.d/99-sysctld.conf
|
|
net.core.netdev_max_backlog = 16384
|
|
net.ipv4.tcp_fastopen = 3
|
|
net.ipv4.tcp_tw_reuse = 1
|
|
net.ipv4.tcp_slow_start_after_idle = 0
|
|
net.ipv4.tcp_mtu_probing = 1
|
|
net.ipv4.tcp_sack = 1
|
|
net.core.default_qdisc = cake
|
|
net.ipv4.tcp_congestion_control = bbr
|
|
net.ipv4.ip_local_port_range = 30000 65535
|
|
vm.vfs_cache_pressure = 50
|
|
vm.mmap_min_addr = 65536
|
|
kernel.printk = 0 0 0 0
|
|
${perf_stream}
|
|
SYSCTL
|
|
cat <<-POLKIT > /etc/polkit-1/rules.d/99-udisks2.rules
|
|
// Original rules: https://github.com/coldfix/udiskie/wiki/Permissions
|
|
// Changes: Added org.freedesktop.udisks2.filesystem-mount-system, as this is used by Dolphin.
|
|
polkit.addRule(function(action, subject) {
|
|
var YES = polkit.Result.YES;
|
|
var permission = {
|
|
// required for udisks1:
|
|
"org.freedesktop.udisks.filesystem-mount": YES,
|
|
"org.freedesktop.udisks.luks-unlock": YES,
|
|
"org.freedesktop.udisks.drive-eject": YES,
|
|
"org.freedesktop.udisks.drive-detach": YES,
|
|
// required for udisks2:
|
|
"org.freedesktop.udisks2.filesystem-mount": YES,
|
|
"org.freedesktop.udisks2.encrypted-unlock": YES,
|
|
"org.freedesktop.udisks2.eject-media": YES,
|
|
"org.freedesktop.udisks2.power-off-drive": YES,
|
|
// Dolphin specific:
|
|
"org.freedesktop.udisks2.filesystem-mount-system": YES,
|
|
// required for udisks2 if using udiskie from another seat (e.g. systemd):
|
|
"org.freedesktop.udisks2.filesystem-mount-other-seat": YES,
|
|
"org.freedesktop.udisks2.filesystem-unmount-others": YES,
|
|
"org.freedesktop.udisks2.encrypted-unlock-other-seat": YES,
|
|
"org.freedesktop.udisks2.encrypted-unlock-system": YES,
|
|
"org.freedesktop.udisks2.eject-media-other-seat": YES,
|
|
"org.freedesktop.udisks2.power-off-drive-other-seat": YES
|
|
};
|
|
if (subject.isInGroup("wheel")) {
|
|
return permission[action.id];
|
|
}
|
|
});
|
|
POLKIT
|
|
mkdir -p /etc/systemd/journald.conf.d > ${void} 2>&1
|
|
cat <<-JOURNAL > /etc/systemd/journald.conf.d/00-journald.conf
|
|
[Journal]
|
|
SystemMaxUse=100M
|
|
JOURNAL
|
|
mkdir -p /etc/systemd/user.conf.d > ${void} 2>&1
|
|
cat <<-TIMEOUT > /etc/systemd/user.conf.d/00-timeout.conf
|
|
[Manager]
|
|
DefaultTimeoutStopSec=5s
|
|
DefaultTimeoutAbortSec=5s
|
|
TIMEOUT
|
|
sed -i \
|
|
-e '/^# set linenumbers/s/^#//' \
|
|
-e '/^# set minibar/s/^#//' \
|
|
-e '/^# set mouse/s/^#//' /etc/nanorc
|
|
echo " include /usr/share/nano/*.nanorc" | tee -a /etc/nanorc
|
|
echo tcp_bbr | tee /etc/modules-load.d/modulesd.conf
|
|
cat <<-SUDOERS > /etc/sudoers.d/sudoersd
|
|
Defaults pwfeedback
|
|
Defaults editor=/usr/bin/nano
|
|
%wheel ALL=(ALL) ALL
|
|
SUDOERS
|
|
visudo -c /etc/sudoers.d/sudoersd
|
|
SYS_OPTM
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
if [[ -d /mnt/etc/udisks2 ]]; then
|
|
local stage_prompt="Udisks2 Mount Options"
|
|
if arch-chroot /mnt <<-UDISKS2 > "${void}" 2>&1 2> "${log}" ; then
|
|
cat <<-UDISKS_CONF > /etc/udisks2/mount_options.conf
|
|
[defaults]
|
|
ntfs_drivers=ntfs3,ntfs
|
|
ntfs:ntfs3_defaults=uid=*,gid=*,windows_names
|
|
ntfs:ntfs_defaults=uid=*,gid=*,windows_names
|
|
exfat_defaults=uid=*,gid=*,errors=remount-ro
|
|
UDISKS_CONF
|
|
UDISKS2
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
fi
|
|
if [[ -n "${REGDOM}" ]]; then
|
|
local stage_prompt="Wpa_Supplicant Configuration"
|
|
if arch-chroot /mnt <<-WPA > "${void}" 2>&1 2> "${log}" ; then
|
|
cat <<-SUPPLICANT > /etc/wpa_supplicant/wpa_supplicant.conf
|
|
country=${REGDOM}
|
|
wps_cred_add_sae=1
|
|
pmf=2
|
|
SUPPLICANT
|
|
WPA
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
fi
|
|
fi
|
|
}
|
|
view_optm() {
|
|
if [[ "${sys_optm}" == "v" ]]; then
|
|
typeset -f optimizations |grep -E 'pacman|/pacman.conf|update-pciids|usermod|systemctl|/etc|/mkinitcpio.conf.d|/makepkg.conf.d|/sysctl.d|/polkit-1/rules.d|/systemd/journald.conf.d|/systemd/user.conf.d|/nanorc|/modules-load.d|/sudoers.d|/udisks2|/wpa_supplicant|/udev/rules.d' | less
|
|
fi
|
|
}
|
|
secboot_sign() {
|
|
if [[ "${sb_sign}" == "y" ]]; then
|
|
local stage_prompt="Secure-Boot Signing"
|
|
if arch-chroot /mnt <<-SECSIGN_MAIN > "${void}" 2>&1 2> "${log}" ; then
|
|
pacman -S --noconfirm sbctl
|
|
sbctl create-keys
|
|
sbctl enroll-keys -m
|
|
sbctl sign -s /boot/vmlinuz-${kernel}
|
|
SECSIGN_MAIN
|
|
:
|
|
else
|
|
stage_fail
|
|
fi
|
|
if [[ "${bootloader}" == "1" && "${uki}" == "y" ]]; then
|
|
if arch-chroot /mnt <<-SDBOOT_SECSIGN > "${void}" 2>&1 2> "${log}" ; then
|
|
sbctl sign -s ${btldr_esp_mount}/EFI/BOOT/${efiname}.EFI
|
|
sbctl sign -s ${btldr_esp_mount}/EFI/Linux/arch-${kernel}.efi
|
|
sbctl sign -s ${btldr_esp_mount}/EFI/systemd/systemd-bootx${bitness}.efi
|
|
sbctl sign -s -o /usr/lib/systemd/boot/efi/systemd-bootx${bitness}.efi.signed /usr/lib/systemd/boot/efi/systemd-bootx${bitness}.efi
|
|
SDBOOT_SECSIGN
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
if [[ "${setrescue}" == "y" ]]; then
|
|
local stage_prompt="Rescue Entry Secure-Boot Signing"
|
|
if arch-chroot /mnt <<-SDBOOT_RESCUE_SECSIGN > "${void}" 2>&1 2> "${log}" ; then
|
|
sbctl sign -s ${btldr_esp_mount}/EFI/Linux/rescue.efi
|
|
SDBOOT_RESCUE_SECSIGN
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
fi
|
|
elif [[ "${bootloader}" == "1" && "${uki}" == "n" ]]; then
|
|
if arch-chroot /mnt <<-SD_XBOOTLDR_SECSIGN > "${void}" 2>&1 2> "${log}" ; then
|
|
sbctl sign -s ${btldr_esp_mount}/EFI/BOOT/${efiname}.EFI
|
|
sbctl sign -s ${btldr_esp_mount}/EFI/systemd/systemd-bootx${bitness}.efi
|
|
sbctl sign -s -o /usr/lib/systemd/boot/efi/systemd-bootx${bitness}.efi.signed /usr/lib/systemd/boot/efi/systemd-bootx${bitness}.efi
|
|
SD_XBOOTLDR_SECSIGN
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
elif [[ "${bootloader}" == "2" ]]; then
|
|
if [[ "${path}" == "1" ]]; then
|
|
if arch-chroot /mnt <<-GRUB_SECSIGN > "${void}" 2>&1 2> "${log}" ; then
|
|
sbctl sign -s ${btldr_esp_mount}/EFI/GRUB/grubx${bitness}.efi
|
|
GRUB_SECSIGN
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
elif [[ "${path}" == "2" ]]; then
|
|
if arch-chroot /mnt <<-GRUB_FALLBACK_SECSIGN > "${void}" 2>&1 2> "${log}" ; then
|
|
sbctl sign -s ${btldr_esp_mount}/EFI/BOOT/${efiname}.EFI
|
|
GRUB_FALLBACK_SECSIGN
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
}
|
|
set_vars() {
|
|
if [[ "${multibooting}" == "y" && "${xbootloader}" == "yes" ]]; then
|
|
uki="n"
|
|
fi
|
|
boot_opts=() # ATTENTION Kernel Cmdline
|
|
MODULES=() # ATTENTION Mkinitcpio Modules
|
|
BINARIES=() # ATTENTION Mkinitcpio Binaries
|
|
HOOKS=() # ATTENTION Mkinitcpio Hooks
|
|
[[ "${fs}" == "2" ]] && BINARIES+=(/usr/bin/btrfs)
|
|
# NOTE: Encrypted Setup
|
|
if [[ "${encrypt}" == "yes" ]]; then
|
|
MODULES+=("${fs_mod}")
|
|
encr_root_dev="/dev/mapper/root"
|
|
encr_root_opts="rd.luks.name=$(blkid -s UUID -o value "${root_dev}")=root"
|
|
encr_root_bootopts="${encr_root_opts} root=${encr_root_dev}"
|
|
if [[ "${swapmode}" == "1" ]]; then
|
|
encr_swap_opts="rd.luks.name=$(blkid -s UUID -o value "${swap_dev}")=swap"
|
|
encr_swap_bootopts="resume=/dev/mapper/swap ${encr_swap_opts}"
|
|
elif [[ "${swapmode}" == "2" ]]; then
|
|
if [[ "${fs}" == "1" ]]; then
|
|
offst="$(filefrag -v /mnt/swapfile | awk '$1=="0:" {print substr($4, 1, length($4)-2)}')"
|
|
elif [[ "${fs}" == "2" ]]; then
|
|
offst="$(btrfs inspect-internal map-swapfile -r /mnt/swap/swapfile)"
|
|
fi
|
|
encr_swap_bootopts="resume=${encr_root_dev} resume_offset=${offst}"
|
|
fi
|
|
if [[ "${sep_home}" == "y" && "${hometype}" == "1" ]]; then
|
|
encr_home_bootopts="rd.luks.name=$(blkid -s UUID -o value "${home_dev}")=home"
|
|
fi
|
|
if [[ "${nvidiaprop}" == "y" ]]; then
|
|
HOOKS+=(systemd keyboard autodetect microcode modconf sd-vconsole block sd-encrypt filesystems)
|
|
else
|
|
HOOKS+=(systemd keyboard autodetect microcode modconf kms sd-vconsole block sd-encrypt filesystems)
|
|
fi
|
|
boot_opts+=("${encr_root_bootopts}")
|
|
[[ -n "${encr_swap_bootopts}" ]] && boot_opts+=("${encr_swap_bootopts}")
|
|
[[ -n "${encr_home_bootopts}" ]] && boot_opts+=("${encr_home_bootopts}")
|
|
# NOTE: Unencrypted Setup
|
|
elif [[ "${encrypt}" == "no" ]]; then
|
|
if [[ "${nvidiaprop}" == "y" ]]; then
|
|
HOOKS+=(systemd autodetect microcode modconf keyboard sd-vconsole block filesystems)
|
|
else
|
|
HOOKS+=(systemd autodetect microcode modconf kms keyboard sd-vconsole block filesystems)
|
|
fi
|
|
[[ "${autoroot}" == "y" ]] && boot_opts+=("${multiroot_bootopts}")
|
|
fi
|
|
# NOTE: Graphics
|
|
gfx_bootopts=()
|
|
if [[ "${nvidiaprop}" == "y" ]]; then
|
|
if [[ -z "${swapmode}" ]]; then
|
|
MODULES+=(nvidia nvidia_modeset nvidia_uvm nvidia_drm)
|
|
fi
|
|
gfx_bootopts+=(nvidia.NVreg_UsePageAttributeTable=1)
|
|
[[ "${vendors}" =~ "Intel" ]] && MODULES+=(i915)
|
|
[[ "${vendors}" =~ "AMD" ]] && MODULES+=(amdgpu radeon)
|
|
[[ "${nogsp}" == "y" ]] && gfx_bootopts+=(nvidia.NVreg_EnableGpuFirmware=0)
|
|
[[ "${lowlat}" == "y" ]] && gfx_bootopts+=(nvidia.NVreg_RegistryDwords=RMIntrLockingMode=1)
|
|
fi
|
|
if [[ "${vendor}" == "AMD" || "${vendors}" =~ "AMD" ]]; then
|
|
if [[ -n "${islands}" && -z "${nvidiaprop}" ]]; then
|
|
MODULES+=(amdgpu radeon)
|
|
fi
|
|
if [[ "${islands}" == "1" ]]; then
|
|
gfx_bootopts+=(amdgpu.dc=1 radeon.si_support=0 amdgpu.si_support=1)
|
|
elif [[ "${islands}" == "2" ]]; then
|
|
gfx_bootopts+=(amdgpu.dc=1 radeon.cik_support=0 amdgpu.cik_support=1)
|
|
fi
|
|
fi
|
|
# NOTE: Finalizing Configuration
|
|
[[ "${fs}" == "1" ]] && HOOKS+=(fsck)
|
|
[[ -n "${gfx_bootopts[*]}" ]] && boot_opts+=("${gfx_bootopts[*]}")
|
|
[[ -n "${cust_bootopts}" ]] && boot_opts+=("${cust_bootopts}")
|
|
[[ -n "${btrfs_bootopts}" ]] && boot_opts+=("${btrfs_bootopts}")
|
|
[[ "${swapmode}" == "3" ]] && boot_opts+=(zswap.enabled=0)
|
|
[[ "${kill_watchdog}" == "y" ]] && boot_opts+=(nowatchdog)
|
|
mkinitcpio_mods="MODULES=(${MODULES[*]})"
|
|
mkinitcpio_bins="BINARIES=(${BINARIES[*]})"
|
|
mkinitcpio_hooks="HOOKS=(${HOOKS[*]})"
|
|
}
|
|
chroot_conf() {
|
|
if [[ "${swapmode}" == "2" ]]; then
|
|
printf "\n\n"
|
|
fi
|
|
title "Chroot & Configure System"
|
|
# NOTE: Desktops Configuration:
|
|
if [[ "${desktop}" != "12" ]]; then
|
|
cnfg
|
|
main_chroot
|
|
if [[ -f /mnt/etc/lightdm/lightdm.conf ]]; then
|
|
if [[ "${desktop}" =~ ^(5|8|10)$ ]]; then
|
|
local stage_prompt="GTK Greeter Configuration"
|
|
if arch-chroot /mnt <<-GTK > "${void}" 2>&1 2> "${log}" ; then
|
|
sed -i 's|^#greeter-session=example-gtk-gnome|greeter-session=lightdm-gtk-greeter|g' /etc/lightdm/lightdm.conf
|
|
GTK
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
elif [[ "${desktop}" == "6" ]]; then
|
|
local stage_prompt="Slick Greeter Configuration"
|
|
if arch-chroot /mnt <<-SLICK > "${void}" 2>&1 2> "${log}" ; then
|
|
sed -i 's|^#greeter-session=example-gtk-gnome|greeter-session=lightdm-slick-greeter|g' /etc/lightdm/lightdm.conf
|
|
SLICK
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
elif [[ "${desktop}" == "7" ]]; then
|
|
local stage_prompt="Deepin Greeter Configuration"
|
|
if arch-chroot /mnt <<-DEEPIN > "${void}" 2>&1 2> "${log}" ; then
|
|
sed -i 's|^#greeter-session=example-gtk-gnome|greeter-session=lightdm-deepin-greeter|g' /etc/lightdm/lightdm.conf
|
|
DEEPIN
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
elif [[ "${desktop}" == "14" ]]; then
|
|
local stage_prompt="Pantheon Greeter Configuration"
|
|
if arch-chroot /mnt <<-PANTHEON > "${void}" 2>&1 2> "${log}" ; then
|
|
sed -i 's|^#greeter-session=example-gtk-gnome|greeter-session=io.elementary.greeter|g' /etc/lightdm/lightdm.conf
|
|
PANTHEON
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
fi
|
|
fi
|
|
if [[ "${vendor}" != "Virtual Machine" && "${desktop}" != "11" ]]; then
|
|
local stage_prompt="Bluetooth Service Activation"
|
|
if arch-chroot /mnt <<-BLUETOOTH > "${void}" 2>&1 2> "${log}" ; then
|
|
systemctl enable bluetooth
|
|
BLUETOOTH
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
fi
|
|
if [[ -n "${displaymanager}" ]]; then
|
|
local stage_prompt="Display Manager Service Activation"
|
|
if arch-chroot /mnt <<-DM > "${void}" 2>&1 2> "${log}" ; then
|
|
systemctl enable ${displaymanager}
|
|
DM
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
fi
|
|
if [[ "${desktop}" != "12" ]]; then
|
|
local stage_prompt="Network Manager Service Activation"
|
|
if arch-chroot /mnt <<-NETWORK > "${void}" 2>&1 2> "${log}" ; then
|
|
systemctl enable NetworkManager
|
|
NETWORK
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
fi
|
|
fi
|
|
# NOTE: Custom System Configuration:
|
|
if [[ "${desktop}" == "12" ]]; then
|
|
cnfg
|
|
main_chroot
|
|
if [[ -n "${customservices}" ]]; then
|
|
local stage_prompt="Custom Service(s) Activation"
|
|
if arch-chroot /mnt <<-CUSTOM_SRVC > "${void}" 2>&1 2> "${log}" ; then
|
|
systemctl enable ${customservices}
|
|
CUSTOM_SRVC
|
|
stage_ok
|
|
else
|
|
stage_fail
|
|
fi
|
|
fi
|
|
fi
|
|
btldrcfg
|
|
trimcfg
|
|
vm_serv
|
|
zramcfg
|
|
nvidia_hook
|
|
mkinitcpio_preset
|
|
var_opts
|
|
foreign
|
|
optimizations
|
|
secboot_sign
|
|
}
|
|
#END SYSTEM FUNCTIONS
|
|
nc="\e[0m"
|
|
red="\e[31m"
|
|
cyan="\e[36m"
|
|
blue="\e[94m"
|
|
green="\e[32m"
|
|
redl="\e[1;31m"
|
|
yellow="\e[33m"
|
|
cyanl="\e[1;36m"
|
|
redbg="\e[1;41m"
|
|
magenta="\e[35m"
|
|
bwhite="\e[0;97m"
|
|
cyanbg="\e[1;46m"
|
|
bluebg="\e[1;44m"
|
|
greenl="\e[1;32m"
|
|
greenbg="\e[1;42m"
|
|
yellowl="\e[1;33m"
|
|
magental="\e[1;35m"
|
|
magentabg="\e[1;45m"
|
|
run_as="$(whoami)"
|
|
void="/dev/null"
|
|
log="Amelia.log"
|
|
tty="$(tty)"
|
|
trg=""
|
|
disks="$(lsblk --nodeps --paths --noheadings --output=name,size,model | cat --number)"
|
|
vars=(LOCALESET="" SETLOCALE="" lcl_slct="" USERNAME="" kernelnmbr="" fs="" gfxcount="" gfxcard="" intelcount="" intelcards="" nvidiacount="" nvidiacards="" amdcount="" amdcards="" vendor="" vendors="" desktop="" terminal="" efi_entr_del="" sanity="" install="" bootldr_pkgs="" devel="" REGDOM="" gfx_bootopts="" btrfs_bootopts="" trim="" swapmode="" greeter="" cust_bootopts="" vmpkgs="" vm_services="" perf_stream="" displaymanager="" wireless_reg="" bitness="" bootloader="" gfx_slct="" espsize="" autoroot="" autoesp="" autoxboot="" autohome="" autoswap="" rootprt="" espprt="" xbootprt="" homeprt="" swapprt="" partok="" instl_drive="" sgdsk_nmbr="" part_mode="" preset="" capacity="" cap_gib="" rootsize="" sgdrive="" cgdrive="" smartpart="" presetpart="" prcnt="" roottype="" stage_prompt="" zram="" xbootloader="" multibooting="" hypervisor="" mkinitcpio_mods="" mkinitcpio_bins="" uki="" ukify="" cng_espmnt="" sep_home="" encr_swap_bootopts="" encr_home_bootopts="" uefimode="" luks_encrypt="" nrg_plc="" multilib="" nvname="" nogsp="" luks_root="" luks_swap="" luks_home="" installation="" kill_watchdog="" oomd="" setrescue="" lowlat="" dev="" web="" web_pkg="" web_aur="" web_slct="" printer="" print_pkgs="" shellnmbr="" shell="" shellname="" shellname2="" shell_pkgs="" sys_optm="" set_ext_opt="" ask_param="" desk_setup="" irqbalance="" thermald="" rngd="" rtkit="" tlp="" CRYPTPASS="" CRYPTPASS2="" show_extopts="" gptslct="" gptok="" gptabort="" nvidiaprop="" nowarning="" efiname="" path="" hometype="" homeform="" LuksParts="" nvidia_aur="" web_aur_url="" session="" alt_session="" session_support="" alt_session_pack="")
|
|
export "${vars[@]}"
|
|
validpkgs=()
|
|
clear
|
|
amelia
|
|
mode_check
|
|
keypress
|
|
clear
|
|
check_fonts
|
|
banner
|
|
uefi_check
|
|
connection_check
|
|
upd_clock
|
|
machine_dtct
|
|
until main_menu; do : ; done
|