##// END OF EJS Templates
Raspi2-3_GenImage
RSS

Cloner depuis https://github.com/drtyhlpr/rpi23-gen-image.git

a
Unknown -
r480:125a2ab9f215
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,498 +1,498
1 1 #
2 2 # Build and Setup RPi2/3 Kernel
3 3 #
4 4
5 5 # Load utility functions
6 6 . ./functions.sh
7 7
8 # Use kali kernel src if nexmon is enabled
9 if [ "$ENABLE_NEXMON" = true ] ; then
10 KERNEL_URL="${NEXMON_URL}"
11 fi
12
8 13 # Fetch and build latest raspberry kernel
9 14 if [ "$BUILD_KERNEL" = true ] ; then
10 15 # Setup source directory
11 16 mkdir -p "${KERNEL_DIR}"
12 17
13 18 # Copy existing kernel sources into chroot directory
14 19 if [ -n "$KERNELSRC_DIR" ] && [ -d "$KERNELSRC_DIR" ] ; then
15 20 # Copy kernel sources and include hidden files
16 21 cp -r "${KERNELSRC_DIR}/". "${KERNEL_DIR}"
17 22
18 23 # Clean the kernel sources
19 24 if [ "$KERNELSRC_CLEAN" = true ] && [ "$KERNELSRC_PREBUILT" = false ] ; then
20 25 make -C "${KERNEL_DIR}" ARCH="${KERNEL_ARCH}" CROSS_COMPILE="${CROSS_COMPILE}" mrproper
21 26 fi
22 27 else # KERNELSRC_DIR=""
23 28 # Create temporary directory for kernel sources
24 29 temp_dir=$(as_nobody mktemp -d)
25 30
26 # Use kali kernel src if nexmon is enabled
27 if [ "$ENABLE_NEXMON" = true ] ; then
28 KERNEL_URL="${NEXMON_URL}"
29 fi
30
31 31 # Fetch current RPi2/3 kernel sources
32 32 if [ -z "${KERNEL_BRANCH}" ] ; then
33 33 as_nobody -H git -C "${temp_dir}" clone --depth=1 "${KERNEL_URL}" linux
34 34 else
35 35 as_nobody -H git -C "${temp_dir}" clone --depth=1 --branch "${KERNEL_BRANCH}" "${KERNEL_URL}" linux
36 36 fi
37 37
38 38 # Copy downloaded kernel sources
39 39 cp -r "${temp_dir}/linux/"* "${KERNEL_DIR}"
40 40
41 41 # Remove temporary directory for kernel sources
42 42 rm -fr "${temp_dir}"
43 43
44 44 # Set permissions of the kernel sources
45 45 chown -R root:root "${R}/usr/src"
46 46 fi
47 47
48 48 # Calculate optimal number of kernel building threads
49 49 if [ "$KERNEL_THREADS" = "1" ] && [ -r /proc/cpuinfo ] ; then
50 50 KERNEL_THREADS=$(grep -c processor /proc/cpuinfo)
51 51 fi
52 52
53 53 # Configure and build kernel
54 54 if [ "$KERNELSRC_PREBUILT" = false ] ; then
55 55 # Remove device, network and filesystem drivers from kernel configuration
56 56 if [ "$KERNEL_REDUCE" = true ] ; then
57 57 make -C "${KERNEL_DIR}" ARCH="${KERNEL_ARCH}" CROSS_COMPILE="${CROSS_COMPILE}" "${KERNEL_DEFCONFIG}"
58 58 sed -i\
59 59 -e "s/\(^CONFIG_SND.*\=\).*/\1n/"\
60 60 -e "s/\(^CONFIG_SOUND.*\=\).*/\1n/"\
61 61 -e "s/\(^CONFIG_AC97.*\=\).*/\1n/"\
62 62 -e "s/\(^CONFIG_VIDEO_.*\=\).*/\1n/"\
63 63 -e "s/\(^CONFIG_MEDIA_TUNER.*\=\).*/\1n/"\
64 64 -e "s/\(^CONFIG_DVB.*\=\)[ym]/\1n/"\
65 65 -e "s/\(^CONFIG_REISERFS.*\=\).*/\1n/"\
66 66 -e "s/\(^CONFIG_JFS.*\=\).*/\1n/"\
67 67 -e "s/\(^CONFIG_XFS.*\=\).*/\1n/"\
68 68 -e "s/\(^CONFIG_GFS2.*\=\).*/\1n/"\
69 69 -e "s/\(^CONFIG_OCFS2.*\=\).*/\1n/"\
70 70 -e "s/\(^CONFIG_BTRFS.*\=\).*/\1n/"\
71 71 -e "s/\(^CONFIG_HFS.*\=\).*/\1n/"\
72 72 -e "s/\(^CONFIG_JFFS2.*\=\)[ym]/\1n/"\
73 73 -e "s/\(^CONFIG_UBIFS.*\=\).*/\1n/"\
74 74 -e "s/\(^CONFIG_SQUASHFS.*\=\)[ym]/\1n/"\
75 75 -e "s/\(^CONFIG_W1.*\=\)[ym]/\1n/"\
76 76 -e "s/\(^CONFIG_HAMRADIO.*\=\).*/\1n/"\
77 77 -e "s/\(^CONFIG_CAN.*\=\).*/\1n/"\
78 78 -e "s/\(^CONFIG_IRDA.*\=\).*/\1n/"\
79 79 -e "s/\(^CONFIG_BT_.*\=\).*/\1n/"\
80 80 -e "s/\(^CONFIG_WIMAX.*\=\)[ym]/\1n/"\
81 81 -e "s/\(^CONFIG_6LOWPAN.*\=\).*/\1n/"\
82 82 -e "s/\(^CONFIG_IEEE802154.*\=\).*/\1n/"\
83 83 -e "s/\(^CONFIG_NFC.*\=\).*/\1n/"\
84 84 -e "s/\(^CONFIG_FB_TFT=.*\=\).*/\1n/"\
85 85 -e "s/\(^CONFIG_TOUCHSCREEN.*\=\).*/\1n/"\
86 86 -e "s/\(^CONFIG_USB_GSPCA_.*\=\).*/\1n/"\
87 87 -e "s/\(^CONFIG_DRM.*\=\).*/\1n/"\
88 88 "${KERNEL_DIR}/.config"
89 89 fi
90 90
91 91 if [ "$KERNELSRC_CONFIG" = true ] ; then
92 92 # Load default raspberry kernel configuration
93 93 make -C "${KERNEL_DIR}" ARCH="${KERNEL_ARCH}" CROSS_COMPILE="${CROSS_COMPILE}" "${KERNEL_DEFCONFIG}"
94 94
95 95 #Switch to KERNELSRC_DIR so we can use set_kernel_config
96 96 cd "${KERNEL_DIR}" || exit
97 97
98 98 # enable ZSWAP see https://askubuntu.com/a/472227 or https://wiki.archlinux.org/index.php/zswap
99 99 if [ "$KERNEL_ZSWAP" = true ] ; then
100 100 set_kernel_config CONFIG_ZPOOL y
101 101 set_kernel_config CONFIG_ZSWAP y
102 102 set_kernel_config CONFIG_ZBUD y
103 103 set_kernel_config CONFIG_Z3FOLD y
104 104 set_kernel_config CONFIG_ZSMALLOC y
105 105 set_kernel_config CONFIG_PGTABLE_MAPPING y
106 106 fi
107 107
108 108 # enable basic KVM support; see https://www.raspberrypi.org/forums/viewtopic.php?f=63&t=210546&start=25#p1300453
109 109 if [ "$KERNEL_VIRT" = true ] && { [ "$RPI_MODEL" = 2 ] || [ "$RPI_MODEL" = 3 ] || [ "$RPI_MODEL" = 3P ] ; } ; then
110 110 set_kernel_config CONFIG_VIRTUALIZATION y
111 111 set_kernel_config CONFIG_KVM y
112 112 set_kernel_config CONFIG_VHOST_NET m
113 113 set_kernel_config CONFIG_VHOST_CROSS_ENDIAN_LEGACY y
114 114 fi
115 115
116 116 # Netfilter kernel support See https://github.com/raspberrypi/linux/issues/2177#issuecomment-354647406
117 117 if [ "$KERNEL_NF" = true ] ; then
118 118 set_kernel_config CONFIG_IP_NF_TARGET_SYNPROXY m
119 119 set_kernel_config CONFIG_NETFILTER_XT_MATCH_CGROUP m
120 120 set_kernel_config CONFIG_NETFILTER_XT_MATCH_IPCOMP m
121 121 set_kernel_config CONFIG_NETFILTER_XT_MATCH_SOCKET m
122 122 set_kernel_config CONFIG_NFT_FIB_INET m
123 123 set_kernel_config CONFIG_NFT_FIB_IPV4 m
124 124 set_kernel_config CONFIG_NFT_FIB_IPV6 m
125 125 set_kernel_config CONFIG_NFT_FIB_NETDEV m
126 126 set_kernel_config CONFIG_NFT_OBJREF m
127 127 set_kernel_config CONFIG_NFT_RT m
128 128 set_kernel_config CONFIG_NFT_SET_BITMAP m
129 129 set_kernel_config CONFIG_NF_CONNTRACK_TIMEOUT y
130 130 set_kernel_config CONFIG_NF_LOG_ARP m
131 131 set_kernel_config CONFIG_NF_SOCKET_IPV4 m
132 132 set_kernel_config CONFIG_NF_SOCKET_IPV6 m
133 133 set_kernel_config CONFIG_BRIDGE_EBT_BROUTE m
134 134 set_kernel_config CONFIG_BRIDGE_EBT_T_FILTER m
135 135 set_kernel_config CONFIG_BRIDGE_NF_EBTABLES m
136 136 set_kernel_config CONFIG_IP6_NF_IPTABLES m
137 137 set_kernel_config CONFIG_IP6_NF_MATCH_AH m
138 138 set_kernel_config CONFIG_IP6_NF_MATCH_EUI64 m
139 139 set_kernel_config CONFIG_IP6_NF_NAT m
140 140 set_kernel_config CONFIG_IP6_NF_TARGET_MASQUERADE m
141 141 set_kernel_config CONFIG_IP6_NF_TARGET_NPT m
142 142 set_kernel_config CONFIG_IP_SET_BITMAP_IPMAC m
143 143 set_kernel_config CONFIG_IP_SET_BITMAP_PORT m
144 144 set_kernel_config CONFIG_IP_SET_HASH_IP m
145 145 set_kernel_config CONFIG_IP_SET_HASH_IPMARK m
146 146 set_kernel_config CONFIG_IP_SET_HASH_IPPORT m
147 147 set_kernel_config CONFIG_IP_SET_HASH_IPPORTIP m
148 148 set_kernel_config CONFIG_IP_SET_HASH_IPPORTNET m
149 149 set_kernel_config CONFIG_IP_SET_HASH_MAC m
150 150 set_kernel_config CONFIG_IP_SET_HASH_NET m
151 151 set_kernel_config CONFIG_IP_SET_HASH_NETIFACE m
152 152 set_kernel_config CONFIG_IP_SET_HASH_NETNET m
153 153 set_kernel_config CONFIG_IP_SET_HASH_NETPORT m
154 154 set_kernel_config CONFIG_IP_SET_HASH_NETPORTNET m
155 155 set_kernel_config CONFIG_IP_SET_LIST_SET m
156 156 set_kernel_config CONFIG_NETFILTER_XTABLES m
157 157 set_kernel_config CONFIG_NETFILTER_XTABLES m
158 158 set_kernel_config CONFIG_NFT_BRIDGE_META m
159 159 set_kernel_config CONFIG_NFT_BRIDGE_REJECT m
160 160 set_kernel_config CONFIG_NFT_CHAIN_NAT_IPV4 m
161 161 set_kernel_config CONFIG_NFT_CHAIN_NAT_IPV6 m
162 162 set_kernel_config CONFIG_NFT_CHAIN_ROUTE_IPV4 m
163 163 set_kernel_config CONFIG_NFT_CHAIN_ROUTE_IPV6 m
164 164 set_kernel_config CONFIG_NFT_COMPAT m
165 165 set_kernel_config CONFIG_NFT_COUNTER m
166 166 set_kernel_config CONFIG_NFT_CT m
167 167 set_kernel_config CONFIG_NFT_DUP_IPV4 m
168 168 set_kernel_config CONFIG_NFT_DUP_IPV6 m
169 169 set_kernel_config CONFIG_NFT_DUP_NETDEV m
170 170 set_kernel_config CONFIG_NFT_EXTHDR m
171 171 set_kernel_config CONFIG_NFT_FWD_NETDEV m
172 172 set_kernel_config CONFIG_NFT_HASH m
173 173 set_kernel_config CONFIG_NFT_LIMIT m
174 174 set_kernel_config CONFIG_NFT_LOG m
175 175 set_kernel_config CONFIG_NFT_MASQ m
176 176 set_kernel_config CONFIG_NFT_MASQ_IPV4 m
177 177 set_kernel_config CONFIG_NFT_MASQ_IPV6 m
178 178 set_kernel_config CONFIG_NFT_META m
179 179 set_kernel_config CONFIG_NFT_NAT m
180 180 set_kernel_config CONFIG_NFT_NUMGEN m
181 181 set_kernel_config CONFIG_NFT_QUEUE m
182 182 set_kernel_config CONFIG_NFT_QUOTA m
183 183 set_kernel_config CONFIG_NFT_REDIR m
184 184 set_kernel_config CONFIG_NFT_REDIR_IPV4 m
185 185 set_kernel_config CONFIG_NFT_REDIR_IPV6 m
186 186 set_kernel_config CONFIG_NFT_REJECT m
187 187 set_kernel_config CONFIG_NFT_REJECT_INET m
188 188 set_kernel_config CONFIG_NFT_REJECT_IPV4 m
189 189 set_kernel_config CONFIG_NFT_REJECT_IPV6 m
190 190 set_kernel_config CONFIG_NFT_SET_HASH m
191 191 set_kernel_config CONFIG_NFT_SET_RBTREE m
192 192 set_kernel_config CONFIG_NF_CONNTRACK_IPV4 m
193 193 set_kernel_config CONFIG_NF_CONNTRACK_IPV6 m
194 194 set_kernel_config CONFIG_NF_DEFRAG_IPV4 m
195 195 set_kernel_config CONFIG_NF_DEFRAG_IPV6 m
196 196 set_kernel_config CONFIG_NF_DUP_IPV4 m
197 197 set_kernel_config CONFIG_NF_DUP_IPV6 m
198 198 set_kernel_config CONFIG_NF_DUP_NETDEV m
199 199 set_kernel_config CONFIG_NF_LOG_BRIDGE m
200 200 set_kernel_config CONFIG_NF_LOG_IPV4 m
201 201 set_kernel_config CONFIG_NF_LOG_IPV6 m
202 202 set_kernel_config CONFIG_NF_NAT_IPV4 m
203 203 set_kernel_config CONFIG_NF_NAT_IPV6 m
204 204 set_kernel_config CONFIG_NF_NAT_MASQUERADE_IPV4 m
205 205 set_kernel_config CONFIG_NF_NAT_MASQUERADE_IPV6 m
206 206 set_kernel_config CONFIG_NF_NAT_PPTP m
207 207 set_kernel_config CONFIG_NF_NAT_PROTO_GRE m
208 208 set_kernel_config CONFIG_NF_NAT_REDIRECT m
209 209 set_kernel_config CONFIG_NF_NAT_SIP m
210 210 set_kernel_config CONFIG_NF_NAT_SNMP_BASIC m
211 211 set_kernel_config CONFIG_NF_NAT_TFTP m
212 212 set_kernel_config CONFIG_NF_REJECT_IPV4 m
213 213 set_kernel_config CONFIG_NF_REJECT_IPV6 m
214 214 set_kernel_config CONFIG_NF_TABLES m
215 215 set_kernel_config CONFIG_NF_TABLES_ARP m
216 216 set_kernel_config CONFIG_NF_TABLES_BRIDGE m
217 217 set_kernel_config CONFIG_NF_TABLES_INET m
218 218 set_kernel_config CONFIG_NF_TABLES_IPV4 m
219 219 set_kernel_config CONFIG_NF_TABLES_IPV6 m
220 220 set_kernel_config CONFIG_NF_TABLES_NETDEV m
221 221 fi
222 222
223 223 # Enables BPF syscall for systemd-journald see https://github.com/torvalds/linux/blob/master/init/Kconfig#L848 or https://groups.google.com/forum/#!topic/linux.gentoo.user/_2aSc_ztGpA
224 224 if [ "$KERNEL_BPF" = true ] ; then
225 225 set_kernel_config CONFIG_BPF_SYSCALL y
226 226 set_kernel_config CONFIG_BPF_EVENTS y
227 227 set_kernel_config CONFIG_BPF_STREAM_PARSER y
228 228 set_kernel_config CONFIG_CGROUP_BPF y
229 229 fi
230 230
231 231 # KERNEL_DEFAULT_GOV was set by user
232 232 if ! [ "$KERNEL_DEFAULT_GOV" = POWERSAVE ] && [ -n "$KERNEL_DEFAULT_GOV" ]; then
233 233 # unset default governor
234 234 unset_kernel_config CONFIG_CPU_FREQ_DEFAULT_GOV_POWERSAVE
235 235
236 236 case "$KERNEL_DEFAULT_GOV" in
237 237 "PERFORMANCE")
238 238 set_kernel_config CONFIG_CPU_FREQ_DEFAULT_GOV_PERFORMANCE y
239 239 ;;
240 240 "USERSPACE")
241 241 set_kernel_config CONFIG_CPU_FREQ_DEFAULT_GOV_USERSPACE y
242 242 ;;
243 243 "ONDEMAND")
244 244 set_kernel_config CONFIG_CPU_FREQ_DEFAULT_GOV_ONDEMAND y
245 245 ;;
246 246 "CONSERVATIVE")
247 247 set_kernel_config CONFIG_CPU_FREQ_DEFAULT_GOV_CONSERVATIVE y
248 248 ;;
249 249 "CONSERVATIVE")
250 250 set_kernel_config CONFIG_CPU_FREQ_DEFAULT_GOV_SCHEDUTIL y
251 251 ;;
252 252 *)
253 253 echo "error: unsupported default cpu governor"
254 254 exit 1
255 255 ;;
256 256 esac
257 257 fi
258 258
259 259
260 260
261 261 #Revert to previous directory
262 262 cd "${WORKDIR}" || exit
263 263
264 264 # Set kernel configuration parameters to enable qemu emulation
265 265 if [ "$ENABLE_QEMU" = true ] ; then
266 266 echo "CONFIG_FHANDLE=y" >> "${KERNEL_DIR}"/.config
267 267 echo "CONFIG_LBDAF=y" >> "${KERNEL_DIR}"/.config
268 268
269 269 if [ "$ENABLE_CRYPTFS" = true ] ; then
270 270 {
271 271 echo "CONFIG_EMBEDDED=y"
272 272 echo "CONFIG_EXPERT=y"
273 273 echo "CONFIG_DAX=y"
274 274 echo "CONFIG_MD=y"
275 275 echo "CONFIG_BLK_DEV_MD=y"
276 276 echo "CONFIG_MD_AUTODETECT=y"
277 277 echo "CONFIG_BLK_DEV_DM=y"
278 278 echo "CONFIG_BLK_DEV_DM_BUILTIN=y"
279 279 echo "CONFIG_DM_CRYPT=y"
280 280 echo "CONFIG_CRYPTO_BLKCIPHER=y"
281 281 echo "CONFIG_CRYPTO_CBC=y"
282 282 echo "CONFIG_CRYPTO_XTS=y"
283 283 echo "CONFIG_CRYPTO_SHA512=y"
284 284 echo "CONFIG_CRYPTO_MANAGER=y"
285 285 } >> "${KERNEL_DIR}"/.config
286 286 fi
287 287 fi
288 288
289 289 # Copy custom kernel configuration file
290 290 if [ -n "$KERNELSRC_USRCONFIG" ] ; then
291 291 cp "$KERNELSRC_USRCONFIG" "${KERNEL_DIR}"/.config
292 292 fi
293 293
294 294 # Set kernel configuration parameters to their default values
295 295 if [ "$KERNEL_OLDDEFCONFIG" = true ] ; then
296 296 make -C "${KERNEL_DIR}" ARCH="${KERNEL_ARCH}" CROSS_COMPILE="${CROSS_COMPILE}" olddefconfig
297 297 fi
298 298
299 299 # Start menu-driven kernel configuration (interactive)
300 300 if [ "$KERNEL_MENUCONFIG" = true ] ; then
301 301 make -C "${KERNEL_DIR}" ARCH="${KERNEL_ARCH}" CROSS_COMPILE="${CROSS_COMPILE}" menuconfig
302 302 fi
303 303 # end if "$KERNELSRC_CONFIG" = true
304 304 fi
305 305
306 306 # Use ccache to cross compile the kernel
307 307 if [ "$KERNEL_CCACHE" = true ] ; then
308 308 cc="ccache ${CROSS_COMPILE}gcc"
309 309 else
310 310 cc="${CROSS_COMPILE}gcc"
311 311 fi
312 312
313 313 # Cross compile kernel and dtbs
314 314 make -C "${KERNEL_DIR}" -j"${KERNEL_THREADS}" ARCH="${KERNEL_ARCH}" CROSS_COMPILE="${CROSS_COMPILE}" CC="${cc}" "${KERNEL_BIN_IMAGE}" dtbs
315 315
316 316 # Cross compile kernel modules
317 317 if grep -q "CONFIG_MODULES=y" "${KERNEL_DIR}/.config" ; then
318 318 make -C "${KERNEL_DIR}" -j"${KERNEL_THREADS}" ARCH="${KERNEL_ARCH}" CROSS_COMPILE="${CROSS_COMPILE}" CC="${cc}" modules
319 319 fi
320 320 # end if "$KERNELSRC_PREBUILT" = false
321 321 fi
322 322
323 323 # Check if kernel compilation was successful
324 324 if [ ! -r "${KERNEL_DIR}/arch/${KERNEL_ARCH}/boot/${KERNEL_BIN_IMAGE}" ] ; then
325 325 echo "error: kernel compilation failed! (kernel image not found)"
326 326 cleanup
327 327 exit 1
328 328 fi
329 329
330 330 # Install kernel modules
331 331 if [ "$ENABLE_REDUCE" = true ] ; then
332 332 if grep -q "CONFIG_MODULES=y" "${KERNEL_DIR}/.config" ; then
333 333 make -C "${KERNEL_DIR}" ARCH="${KERNEL_ARCH}" CROSS_COMPILE="${CROSS_COMPILE}" INSTALL_MOD_STRIP=1 INSTALL_MOD_PATH=../../.. modules_install
334 334 fi
335 335 else
336 336 if grep -q "CONFIG_MODULES=y" "${KERNEL_DIR}/.config" ; then
337 337 make -C "${KERNEL_DIR}" ARCH="${KERNEL_ARCH}" CROSS_COMPILE="${CROSS_COMPILE}" INSTALL_MOD_PATH=../../.. modules_install
338 338 fi
339 339
340 340 # Install kernel firmware
341 341 if grep -q "^firmware_install:" "${KERNEL_DIR}/Makefile" ; then
342 342 make -C "${KERNEL_DIR}" ARCH="${KERNEL_ARCH}" CROSS_COMPILE="${CROSS_COMPILE}" INSTALL_FW_PATH=../../../lib firmware_install
343 343 fi
344 344 fi
345 345
346 346 # Install kernel headers
347 347 if [ "$KERNEL_HEADERS" = true ] && [ "$KERNEL_REDUCE" = false ] ; then
348 348 make -C "${KERNEL_DIR}" ARCH="${KERNEL_ARCH}" CROSS_COMPILE="${CROSS_COMPILE}" INSTALL_HDR_PATH=../.. headers_install
349 349 fi
350 350 # make tar.gz kernel package - missing os bzw. modules
351 351 #** ** ** WARNING ** ** **
352 352 #Your architecture did not define any architecture-dependent files
353 353 #to be placed into the tarball. Please add those to ./scripts/package/buildtar .
354 354 # make -C "${KERNEL_DIR}" ARCH="${KERNEL_ARCH}" CROSS_COMPILE="${CROSS_COMPILE}" CC="${cc}" targz-pkg
355 355
356 356 # Prepare boot (firmware) directory
357 357 mkdir "${BOOT_DIR}"
358 358
359 359 # Get kernel release version
360 360 KERNEL_VERSION=$(cat "${KERNEL_DIR}/include/config/kernel.release")
361 361
362 362 # Copy kernel configuration file to the boot directory
363 363 install_readonly "${KERNEL_DIR}/.config" "${R}/boot/config-${KERNEL_VERSION}"
364 364
365 365 # Prepare device tree directory
366 366 mkdir "${BOOT_DIR}/overlays"
367 367
368 368 # Ensure the proper .dtb is located
369 369 if [ "$KERNEL_ARCH" = "arm" ] ; then
370 370 for dtb in "${KERNEL_DIR}/arch/${KERNEL_ARCH}/boot/dts/"*.dtb ; do
371 371 if [ -f "${dtb}" ] ; then
372 372 install_readonly "${dtb}" "${BOOT_DIR}/"
373 373 fi
374 374 done
375 375 else
376 376 for dtb in "${KERNEL_DIR}/arch/${KERNEL_ARCH}/boot/dts/broadcom/"*.dtb ; do
377 377 if [ -f "${dtb}" ] ; then
378 378 install_readonly "${dtb}" "${BOOT_DIR}/"
379 379 fi
380 380 done
381 381 fi
382 382
383 383 # Copy compiled dtb device tree files
384 384 if [ -d "${KERNEL_DIR}/arch/${KERNEL_ARCH}/boot/dts/overlays" ] ; then
385 385 for dtb in "${KERNEL_DIR}/arch/${KERNEL_ARCH}/boot/dts/overlays/"*.dtb ; do
386 386 if [ -f "${dtb}" ] ; then
387 387 install_readonly "${dtb}" "${BOOT_DIR}/overlays/"
388 388 fi
389 389 done
390 390
391 391 if [ -f "${KERNEL_DIR}/arch/${KERNEL_ARCH}/boot/dts/overlays/README" ] ; then
392 392 install_readonly "${KERNEL_DIR}/arch/${KERNEL_ARCH}/boot/dts/overlays/README" "${BOOT_DIR}/overlays/README"
393 393 fi
394 394 fi
395 395
396 396 if [ "$ENABLE_UBOOT" = false ] ; then
397 397 # Convert and copy kernel image to the boot directory
398 398 "${KERNEL_DIR}/scripts/mkknlimg" "${KERNEL_DIR}/arch/${KERNEL_ARCH}/boot/${KERNEL_BIN_IMAGE}" "${BOOT_DIR}/${KERNEL_IMAGE}"
399 399 else
400 400 # Copy kernel image to the boot directory
401 401 install_readonly "${KERNEL_DIR}/arch/${KERNEL_ARCH}/boot/${KERNEL_BIN_IMAGE}" "${BOOT_DIR}/${KERNEL_IMAGE}"
402 402 fi
403 403
404 404 # Remove kernel sources
405 405 if [ "$KERNEL_REMOVESRC" = true ] ; then
406 406 rm -fr "${KERNEL_DIR}"
407 407 else
408 408 # Prepare compiled kernel modules
409 409 if grep -q "CONFIG_MODULES=y" "${KERNEL_DIR}/.config" ; then
410 410 if grep -q "^modules_prepare:" "${KERNEL_DIR}/Makefile" ; then
411 411 make -C "${KERNEL_DIR}" ARCH="${KERNEL_ARCH}" CROSS_COMPILE="${CROSS_COMPILE}" modules_prepare
412 412 fi
413 413
414 414 # Create symlinks for kernel modules
415 415 chroot_exec ln -sf /usr/src/linux "/lib/modules/${KERNEL_VERSION}/build"
416 416 chroot_exec ln -sf /usr/src/linux "/lib/modules/${KERNEL_VERSION}/source"
417 417 fi
418 418 fi
419 419
420 420 else # BUILD_KERNEL=false
421 421 # echo Install precompiled kernel...
422 422 # echo error: not implemented
423 423 if [ "$SET_ARCH" = 64 ] && { [ "$RPI_MODEL" = 3 ] || [ "$RPI_MODEL" = 3P ] ; } ; then
424 424
425 425 # Use Sakakis modified kernel if ZSWAP is active
426 426 if [ "$KERNEL_ZSWAP" = true ] || [ "$KERNEL_VIRT" = true ] || [ "$KERNEL_NF" = true ] || [ "$KERNEL_BPF" = true ] ; then
427 427 RPI3_64_KERNEL_URL=RPI3_64_BIS_KERNEL_URL
428 428 fi
429 429
430 430 # Create temporary directory for dl
431 431 temp_dir=$(as_nobody mktemp -d)
432 432
433 433 # Fetch kernel dl
434 434 as_nobody wget -O "${temp_dir}"/kernel.tar.xz -c "$RPI3_64_KERNEL_URL"
435 435
436 436 #extract download
437 437 tar -xJf "${temp_dir}"/kernel.tar.xz -C "${temp_dir}"
438 438
439 439 #move extracted kernel to /boot/firmware
440 440 mkdir "${R}/boot/firmware"
441 441 cp "${temp_dir}"/boot/* "${R}"/boot/firmware/
442 442 cp -r "${temp_dir}"/lib/* "${R}"/lib/
443 443
444 444 # Remove temporary directory for kernel sources
445 445 rm -fr "${temp_dir}"
446 446
447 447 # Set permissions of the kernel sources
448 448 chown -R root:root "${R}/boot/firmware"
449 449 chown -R root:root "${R}/lib/modules"
450 450 fi
451 451
452 452 # INstall Kernel from hypriot comptabile with all Raspberry PI
453 453 if [ "$SET_ARCH" = 32 ] ; then
454 454 # Create temporary directory for dl
455 455 temp_dir=$(as_nobody mktemp -d)
456 456
457 457 # Fetch kernel
458 458 as_nobody wget -O "${temp_dir}"/kernel.deb -c "$RPI_32_KERNEL_URL"
459 459
460 460 # Copy downloaded U-Boot sources
461 461 mv "${temp_dir}"/kernel.deb "${R}"/tmp/kernel.deb
462 462
463 463 # Set permissions
464 464 chown -R root:root "${R}"/tmp/kernel.deb
465 465
466 466 # Install kernel
467 467 chroot_exec dpkg -i /tmp/kernel.deb
468 468
469 469 # move /boot to /boot/firmware to fit script env.
470 470 #mkdir "${BOOT_DIR}"
471 471 mkdir "${temp_dir}"/firmware
472 472 mv "${R}"/boot/* "${temp_dir}"/firmware/
473 473 mv "${temp_dir}"/firmware "${R}"/boot/
474 474
475 475 #same for kernel headers
476 476 if [ "$KERNEL_HEADERS" = true ] ; then
477 477 # Fetch kernel header
478 478 as_nobody wget -O "${temp_dir}"/kernel-header.deb -c "$RPI_32_KERNELHEADER_URL"
479 479 mv "${temp_dir}"/kernel-header.deb "${R}"/tmp/kernel-header.deb
480 480 chown -R root:root "${R}"/tmp/kernel-header.deb
481 481 # Install kernel header
482 482 chroot_exec dpkg -i /tmp/kernel-header.deb
483 483 rm -f "${R}"/tmp/kernel-header.deb
484 484 fi
485 485
486 486 # Remove temporary directory and files
487 487 rm -fr "${temp_dir}"
488 488 rm -f "${R}"/tmp/kernel.deb
489 489 fi
490 490
491 491 # Check if kernel installation was successful
492 492 KERNEL="$(ls -1 "${R}"/boot/firmware/kernel* | sort | tail -n 1)"
493 493 if [ -z "$KERNEL" ] ; then
494 494 echo "error: kernel installation failed! (/boot/kernel* not found)"
495 495 cleanup
496 496 exit 1
497 497 fi
498 498 fi
Show file before | Show file after | Hide comments
@@ -1,271 +1,273
1 1 #
2 2 # Setup RPi2/3 config and cmdline
3 3 #
4 4
5 5 # Load utility functions
6 6 . ./functions.sh
7 7
8 8 #if [ "$BUILD_KERNEL" = true ] ; then
9 9 if [ -n "$RPI_FIRMWARE_DIR" ] && [ -d "$RPI_FIRMWARE_DIR" ] ; then
10 10 # Install boot binaries from local directory
11 11 cp "${RPI_FIRMWARE_DIR}"/boot/bootcode.bin "${BOOT_DIR}"/bootcode.bin
12 12 cp "${RPI_FIRMWARE_DIR}"/boot/fixup.dat "${BOOT_DIR}"/fixup.dat
13 13 cp "${RPI_FIRMWARE_DIR}"/boot/fixup_cd.dat "${BOOT_DIR}"/fixup_cd.dat
14 14 cp "${RPI_FIRMWARE_DIR}"/boot/fixup_x.dat "${BOOT_DIR}"/fixup_x.dat
15 15 cp "${RPI_FIRMWARE_DIR}"/boot/start.elf "${BOOT_DIR}"/start.elf
16 16 cp "${RPI_FIRMWARE_DIR}"/boot/start_cd.elf "${BOOT_DIR}"/start_cd.elf
17 17 cp "${RPI_FIRMWARE_DIR}"/boot/start_x.elf "${BOOT_DIR}"/start_x.elf
18 18 else
19 19 # Create temporary directory for boot binaries
20 20 temp_dir=$(as_nobody mktemp -d)
21 21
22 22 # Install latest boot binaries from raspberry/firmware github
23 23 as_nobody wget -q -O "${temp_dir}/bootcode.bin" "${FIRMWARE_URL}/bootcode.bin"
24 24 as_nobody wget -q -O "${temp_dir}/fixup.dat" "${FIRMWARE_URL}/fixup.dat"
25 25 as_nobody wget -q -O "${temp_dir}/fixup_cd.dat" "${FIRMWARE_URL}/fixup_cd.dat"
26 26 as_nobody wget -q -O "${temp_dir}/fixup_x.dat" "${FIRMWARE_URL}/fixup_x.dat"
27 27 as_nobody wget -q -O "${temp_dir}/start.elf" "${FIRMWARE_URL}/start.elf"
28 28 as_nobody wget -q -O "${temp_dir}/start_cd.elf" "${FIRMWARE_URL}/start_cd.elf"
29 29 as_nobody wget -q -O "${temp_dir}/start_x.elf" "${FIRMWARE_URL}/start_x.elf"
30 30
31 31 # Move downloaded boot binaries
32 32 mv "${temp_dir}/"* "${BOOT_DIR}/"
33 33
34 34 # Remove temporary directory for boot binaries
35 35 rm -fr "${temp_dir}"
36 36
37 37 # Set permissions of the boot binaries
38 38 chown -R root:root "${BOOT_DIR}"
39 39 chmod -R 600 "${BOOT_DIR}"
40 40 fi
41 41 #fi
42 42
43 43 # Setup firmware boot cmdline
44 44 if [ "$ENABLE_UBOOTUSB" = true ] ; then
45 45 CMDLINE="dwc_otg.lpm_enable=0 root=/dev/sda2 rootfstype=ext4 rootflags=commit=100,data=writeback elevator=deadline rootwait console=tty1 init=/bin/systemd"
46 46 else
47 47 if [ "$ENABLE_SPLITFS" = true ] ; then
48 48 CMDLINE="dwc_otg.lpm_enable=0 root=/dev/sda1 rootfstype=ext4 rootflags=commit=100,data=writeback elevator=deadline rootwait console=tty1 init=/bin/systemd"
49 49 else
50 50 CMDLINE="dwc_otg.lpm_enable=0 root=/dev/mmcblk0p2 rootfstype=ext4 rootflags=commit=100,data=writeback elevator=deadline rootwait console=tty1 init=/bin/systemd"
51 51 fi
52 52 fi
53 53
54 54 # Add encrypted root partition to cmdline.txt
55 55 if [ "$ENABLE_CRYPTFS" = true ] ; then
56 56 if [ "$ENABLE_SPLITFS" = true ] ; then
57 57 CMDLINE=$(echo "${CMDLINE}" | sed "s/sda1/mapper\/${CRYPTFS_MAPPING} cryptdevice=\/dev\/sda1:${CRYPTFS_MAPPING}/")
58 58 else
59 59 if [ "$ENABLE_UBOOTUSB" = true ] ; then
60 60 CMDLINE=$(echo "${CMDLINE}" | sed "s/sda2/mapper\/${CRYPTFS_MAPPING} cryptdevice=\/dev\/sda2:${CRYPTFS_MAPPING}/")
61 61 else
62 62 CMDLINE=$(echo "${CMDLINE}" | sed "s/mmcblk0p2/mapper\/${CRYPTFS_MAPPING} cryptdevice=\/dev\/mmcblk0p2:${CRYPTFS_MAPPING}/")
63 63 fi
64 64 fi
65 65 fi
66 66
67 67 if [ "$ENABLE_PRINTK" = true ] ; then
68 68 install_readonly files/sysctl.d/83-rpi-printk.conf "${ETC_DIR}/sysctl.d/83-rpi-printk.conf"
69 69 fi
70 70
71 71 # Install udev rule for serial alias - serial0 = console serial1=bluetooth
72 72 install_readonly files/etc/99-com.rules "${LIB_DIR}/udev/rules.d/99-com.rules"
73 73
74 74 # Remove IPv6 networking support
75 75 if [ "$ENABLE_IPV6" = false ] ; then
76 76 CMDLINE="${CMDLINE} ipv6.disable=1"
77 77 fi
78 78
79 79 # Automatically assign predictable network interface names
80 80 if [ "$ENABLE_IFNAMES" = false ] ; then
81 81 CMDLINE="${CMDLINE} net.ifnames=0"
82 82 else
83 83 CMDLINE="${CMDLINE} net.ifnames=1"
84 84 fi
85 85
86 86 # Install firmware config
87 87 install_readonly files/boot/config.txt "${BOOT_DIR}/config.txt"
88 88
89 89 #locks cpu at max frequency
90 90 if [ "$ENABLE_TURBO" = true ] ; then
91 91 echo "force_turbo=1" >> "${BOOT_DIR}/config.txt"
92 92 # helps to avoid sdcard corruption when force_turbo is enabled.
93 93 echo "boot_delay=1" >> "${BOOT_DIR}/config.txt"
94 94 fi
95 95
96 96 if [ "$RPI_MODEL" = 0 ] || [ "$RPI_MODEL" = 3 ] || [ "$RPI_MODEL" = 3P ] ; then
97 97
98 98 # Bluetooth enabled
99 99 if [ "$ENABLE_BLUETOOTH" = true ] ; then
100 100 # Create temporary directory for Bluetooth sources
101 101 temp_dir=$(as_nobody mktemp -d)
102 102
103 103 # Fetch Bluetooth sources
104 104 as_nobody git -C "${temp_dir}" clone "${BLUETOOTH_URL}"
105 105
106 106 # Copy downloaded sources
107 107 mv "${temp_dir}/pi-bluetooth" "${R}/tmp/"
108 108
109 109 # Bluetooth firmware from arch aur https://aur.archlinux.org/packages/pi-bluetooth/
110 110 as_nobody wget -q -O "${R}/tmp/pi-bluetooth/LICENCE.broadcom_bcm43xx" https://aur.archlinux.org/cgit/aur.git/plain/LICENCE.broadcom_bcm43xx?h=pi-bluetooth
111 111 as_nobody wget -q -O "${R}/tmp/pi-bluetooth/BCM43430A1.hcd" https://aur.archlinux.org/cgit/aur.git/plain/BCM43430A1.hcd?h=pi-bluetooth
112 112
113 113 # Set permissions
114 114 chown -R root:root "${R}/tmp/pi-bluetooth"
115 115
116 116 # Install tools
117 117 install_readonly "${R}/tmp/pi-bluetooth/usr/bin/btuart" "${R}/usr/bin/btuart"
118 118 install_readonly "${R}/tmp/pi-bluetooth/usr/bin/bthelper" "${R}/usr/bin/bthelper"
119 chmod +x "${R}/usr/bin/bthelper"
120 chmod +x "${R}/usr/bin/btuart"
119 121
120 122 # Install bluetooth udev rule
121 123 install_readonly "${R}/tmp/pi-bluetooth/lib/udev/rules.d/90-pi-bluetooth.rules" "${LIB_DIR}/udev/rules.d/90-pi-bluetooth.rules"
122 124
123 125 # Install Firmware Flash file and apropiate licence
124 126 mkdir -p "$BLUETOOTH_FIRMWARE_DIR"
125 127 install_readonly "${R}/tmp/pi-bluetooth/LICENCE.broadcom_bcm43xx" "${BLUETOOTH_FIRMWARE_DIR}/LICENCE.broadcom_bcm43xx"
126 128 install_readonly "${R}/tmp/pi-bluetooth/BCM43430A1.hcd" "${BLUETOOTH_FIRMWARE_DIR}/LICENCE.broadcom_bcm43xx"
127 129 install_readonly "${R}/tmp/pi-bluetooth/debian/pi-bluetooth.bthelper@.service" "${ETC_DIR}/systemd/system/pi-bluetooth.bthelper@.service"
128 130 install_readonly "${R}/tmp/pi-bluetooth/debian/pi-bluetooth.hciuart.service" "${ETC_DIR}/systemd/system/pi-bluetooth.hciuart.service"
129 131
130 132 # Remove temporary directories
131 133 rm -fr "${temp_dir}"
132 134 rm -fr "${R}"/tmp/pi-bluetooth
133 135
134 136 # Switch Pi3 Bluetooth function to use the mini-UART (ttyS0) and restore UART0/ttyAMA0 over GPIOs 14 & 15. Slow Bluetooth and slow cpu. Use /dev/ttyS0 instead of /dev/ttyAMA0
135 137 if [ "$ENABLE_MINIUART_OVERLAY" = true ] ; then
136 138
137 139 # set overlay to swap ttyAMA0 and ttyS0
138 140 echo "dtoverlay=pi3-miniuart-bt" >> "${BOOT_DIR}/config.txt"
139 141
140 142 # if force_turbo didn't lock cpu at high speed, lock it at low speed (XOR logic) or miniuart will be broken
141 143 if [ "$ENABLE_TURBO" = false ] ; then
142 144 echo "core_freq=250" >> "${BOOT_DIR}/config.txt"
143 145 fi
144 146 fi
145 147
146 148 # Activate services
147 149 chroot_exec systemctl enable pi-bluetooth.hciuart.service
148 150 chroot_exec systemctl enable pi-bluetooth.bthelper@serial1.service
149 151
150 152 else # if ENABLE_BLUETOOTH = false
151 153 # set overlay to disable bluetooth
152 154 echo "dtoverlay=pi3-disable-bt" >> "${BOOT_DIR}/config.txt"
153 155 fi # ENABLE_BLUETOOTH end
154 156 fi
155 157
156 158 # may need sudo systemctl disable hciuart
157 159 if [ "$ENABLE_CONSOLE" = true ] ; then
158 160 echo "enable_uart=1" >> "${BOOT_DIR}/config.txt"
159 161 # add string to cmdline
160 162 CMDLINE="${CMDLINE} console=serial0,115200"
161 163
162 164 # Enable serial console systemd style
163 165 chroot_exec systemctl enable serial-getty@serial0.service
164 166 else
165 167 echo "enable_uart=0" >> "${BOOT_DIR}/config.txt"
166 168 # disable serial console systemd style
167 169 #chroot_exec systemctl disable serial-getty@serial0.service
168 170 fi
169 171
170 172 # Remove cmdline.txt entry of starting zswap
171 173 if [ "$KERNEL_ZSWAP" = true ] ; then
172 174 CMDLINE="${CMDLINE} zswap.enabled=1 zswap.max_pool_percent=25 zswap.compressor=lz4"
173 175 fi
174 176
175 177 if [ "$ENABLE_SYSTEMDSWAP" = true ] ; then
176 178
177 179 # Remove cmdline.txt entry of starting zswap
178 180 if [ "$KERNEL_ZSWAP" = true ] ; then
179 181 sed -i 's|zswap.enabled=1 zswap.max_pool_percent=25 zswap.compressor=lz4||g'
180 182 fi
181 183 # Create temporary directory for systemd-swap sources
182 184 temp_dir=$(as_nobody mktemp -d)
183 185
184 186 # Fetch systemd-swap sources
185 187 as_nobody git -C "${temp_dir}" clone "${ZSWAP_URL}"
186 188
187 189 # Copy downloaded systemd-swap sources
188 190 mv "${temp_dir}/systemd-swap" "${R}/tmp/"
189 191
190 192 # Set permissions of the systemd-swap sources
191 193 chown -R root:root "${R}/tmp/systemd-swap"
192 194
193 195 # Remove temporary directory for systemd-swap sources
194 196 rm -fr "${temp_dir}"
195 197
196 198 # Change into downloaded src dir
197 199 cd "${R}/tmp/systemd-swap" || exit
198 200
199 201 # Build package
200 202 . ./systemd-swap/package.sh debian
201 203
202 204 # Install package
203 205 chroot_exec dpkg -i /tmp/systemd-swap/systemd-swap-*any.deb
204 206
205 207 # Enable service
206 208 chroot_exec systemctl enable systemd-swap
207 209
208 210 # Change back into script root dir
209 211 cd "${WORKDIR}" || exit
210 212 fi
211 213
212 214 # Install firmware boot cmdline
213 215 echo "${CMDLINE}" > "${BOOT_DIR}/cmdline.txt"
214 216
215 217 # Setup minimal GPU memory allocation size: 16MB (no X)
216 218 if [ "$ENABLE_MINGPU" = true ] ; then
217 219 echo "gpu_mem=16" >> "${BOOT_DIR}/config.txt"
218 220 fi
219 221
220 222 # Setup boot with initramfs
221 223 if [ "$ENABLE_INITRAMFS" = true ] ; then
222 224 echo "initramfs initramfs-${KERNEL_VERSION} followkernel" >> "${BOOT_DIR}/config.txt"
223 225 fi
224 226
225 227 # Create firmware configuration and cmdline symlinks
226 228 ln -sf firmware/config.txt "${R}/boot/config.txt"
227 229 ln -sf firmware/cmdline.txt "${R}/boot/cmdline.txt"
228 230
229 231 # Install and setup kernel modules to load at boot
230 232 mkdir -p "${LIB_DIR}/modules-load.d/"
231 233 install_readonly files/modules/rpi2.conf "${LIB_DIR}/modules-load.d/rpi2.conf"
232 234
233 235 # Load hardware random module at boot
234 236 if [ "$ENABLE_HWRANDOM" = true ] && [ "$BUILD_KERNEL" = false ] ; then
235 237 sed -i "s/^# bcm2708_rng/bcm2708_rng/" "${LIB_DIR}/modules-load.d/rpi2.conf"
236 238 fi
237 239
238 240 # Load sound module at boot
239 241 if [ "$ENABLE_SOUND" = true ] ; then
240 242 sed -i "s/^# snd_bcm2835/snd_bcm2835/" "${LIB_DIR}/modules-load.d/rpi2.conf"
241 243 else
242 244 echo "dtparam=audio=off" >> "${BOOT_DIR}/config.txt"
243 245 fi
244 246
245 247 # Enable I2C interface
246 248 if [ "$ENABLE_I2C" = true ] ; then
247 249 echo "dtparam=i2c_arm=on" >> "${BOOT_DIR}/config.txt"
248 250 sed -i "s/^# i2c-bcm2708/i2c-bcm2708/" "${LIB_DIR}/modules-load.d/rpi2.conf"
249 251 sed -i "s/^# i2c-dev/i2c-dev/" "${LIB_DIR}/modules-load.d/rpi2.conf"
250 252 fi
251 253
252 254 # Enable SPI interface
253 255 if [ "$ENABLE_SPI" = true ] ; then
254 256 echo "dtparam=spi=on" >> "${BOOT_DIR}/config.txt"
255 257 echo "spi-bcm2708" >> "${LIB_DIR}/modules-load.d/rpi2.conf"
256 258 if [ "$RPI_MODEL" = 3 ] || [ "$RPI_MODEL" = 3P ]; then
257 259 sed -i "s/spi-bcm2708/spi-bcm2835/" "${LIB_DIR}/modules-load.d/rpi2.conf"
258 260 fi
259 261 fi
260 262
261 263 # Disable RPi2/3 under-voltage warnings
262 264 if [ -n "$DISABLE_UNDERVOLT_WARNINGS" ] ; then
263 265 echo "avoid_warnings=${DISABLE_UNDERVOLT_WARNINGS}" >> "${BOOT_DIR}/config.txt"
264 266 fi
265 267
266 268 # Install kernel modules blacklist
267 269 mkdir -p "${ETC_DIR}/modprobe.d/"
268 270 install_readonly files/modules/raspi-blacklist.conf "${ETC_DIR}/modprobe.d/raspi-blacklist.conf"
269 271
270 272 # Install sysctl.d configuration files
271 273 install_readonly files/sysctl.d/81-rpi-vm.conf "${ETC_DIR}/sysctl.d/81-rpi-vm.conf"
Show file before | Show file after | Hide comments
@@ -1,862 +1,867
1 1 #!/bin/sh
2 2 ########################################################################
3 3 # rpi23-gen-image.sh 2015-2017
4 4 #
5 5 # Advanced Debian "stretch" and "buster" bootstrap script for Raspberry Pi
6 6 #
7 7 # This program is free software; you can redistribute it and/or
8 8 # modify it under the terms of the GNU General Public License
9 9 # as published by the Free Software Foundation; either version 2
10 10 # of the License, or (at your option) any later version.
11 11 #
12 12 # Copyright (C) 2015 Jan Wagner <mail@jwagner.eu>
13 13 #
14 14 # Big thanks for patches and enhancements by 20+ github contributors!
15 15 ########################################################################
16 16
17 17 # Are we running as root?
18 18 if [ "$(id -u)" -ne "0" ] ; then
19 19 echo "error: this script must be executed with root privileges!"
20 20 exit 1
21 21 fi
22 22
23 23 # Check if ./functions.sh script exists
24 24 if [ ! -r "./functions.sh" ] ; then
25 25 echo "error: './functions.sh' required script not found!"
26 26 exit 1
27 27 fi
28 28
29 29 # Load utility functions
30 30 . ./functions.sh
31 31
32 32 # Load parameters from configuration template file
33 33 if [ -n "$CONFIG_TEMPLATE" ] ; then
34 34 use_template
35 35 fi
36 36
37 37 # Introduce settings
38 38 set -e
39 39 echo -n -e "\n#\n# RPi 0/1/2/3 Bootstrap Settings\n#\n"
40 40 set -x
41 41
42 42 # Raspberry Pi model configuration
43 43 RPI_MODEL=${RPI_MODEL:=2}
44 44
45 45 # Debian release
46 46 RELEASE=${RELEASE:=buster}
47 47
48 48 # Kernel Branch
49 49 KERNEL_BRANCH=${KERNEL_BRANCH:=""}
50 50
51 51 # URLs
52 52 KERNEL_URL=${KERNEL_URL:=https://github.com/raspberrypi/linux}
53 53 FIRMWARE_URL=${FIRMWARE_URL:=https://github.com/raspberrypi/firmware/raw/master/boot}
54 54 WLAN_FIRMWARE_URL=${WLAN_FIRMWARE_URL:=https://github.com/RPi-Distro/firmware-nonfree/raw/master/brcm}
55 55 COLLABORA_URL=${COLLABORA_URL:=https://repositories.collabora.co.uk/debian}
56 56 FBTURBO_URL=${FBTURBO_URL:=https://github.com/ssvb/xf86-video-fbturbo.git}
57 57 UBOOT_URL=${UBOOT_URL:=https://git.denx.de/u-boot.git}
58 58 VIDEOCORE_URL=${VIDEOCORE_URL:=https://github.com/raspberrypi/userland}
59 59 BLUETOOTH_URL=${BLUETOOTH_URL:=https://github.com/RPi-Distro/pi-bluetooth.git}
60 60 NEXMON_URL=${NEXMON_URL:=https://github.com/seemoo-lab/nexmon.git}
61 61 SYSTEMDSWAP_URL=${SYSTEMDSWAP_URL:=https://github.com/Nefelim4ag/systemd-swap.git}
62 62
63 63 # Kernel deb packages for 32bit kernel
64 64 RPI_32_KERNEL_URL=${RPI_32_KERNEL_URL:=https://github.com/hypriot/rpi-kernel/releases/download/v4.14.34/raspberrypi-kernel_20180422-141901_armhf.deb}
65 65 RPI_32_KERNELHEADER_URL=${RPI_32_KERNELHEADER_URL:=https://github.com/hypriot/rpi-kernel/releases/download/v4.14.34/raspberrypi-kernel-headers_20180422-141901_armhf.deb}
66 66 # Kernel has KVM and zswap enabled - use if KERNEL_* parameters and precompiled kernel are used
67 67 RPI3_64_BIS_KERNEL_URL=${RPI3_64_BIS_KERNEL_URL:=https://github.com/sakaki-/bcmrpi3-kernel-bis/releases/download/4.14.80.20181113/bcmrpi3-kernel-bis-4.14.80.20181113.tar.xz}
68 68 # Default precompiled 64bit kernel
69 69 RPI3_64_DEF_KERNEL_URL=${RPI3_64_DEF_KERNEL_URL:=https://github.com/sakaki-/bcmrpi3-kernel/releases/download/4.14.80.20181113/bcmrpi3-kernel-4.14.80.20181113.tar.xz}
70 70 # Generic
71 71 RPI3_64_KERNEL_URL=${RPI3_64_KERNEL_URL:=$RPI3_64_DEF_KERNEL_URL}
72 72
73 73 # Build directories
74 74 WORKDIR=$(pwd)
75 75 BASEDIR=${BASEDIR:=${WORKDIR}/images/${RELEASE}}
76 76 BUILDDIR="${BASEDIR}/build"
77 77
78 78 # Chroot directories
79 79 R="${BUILDDIR}/chroot"
80 80 ETC_DIR="${R}/etc"
81 81 LIB_DIR="${R}/lib"
82 82 BOOT_DIR="${R}/boot/firmware"
83 83 KERNEL_DIR="${R}/usr/src/linux"
84 84 WLAN_FIRMWARE_DIR="${LIB_DIR}/firmware/brcm"
85 85 BLUETOOTH_FIRMWARE_DIR="${ETC_DIR}/firmware/bt"
86 86
87 87 # Firmware directory: Blank if download from github
88 88 RPI_FIRMWARE_DIR=${RPI_FIRMWARE_DIR:=""}
89 89
90 90 # General settings
91 91 SET_ARCH=${SET_ARCH:=32}
92 92 HOSTNAME=${HOSTNAME:=rpi${RPI_MODEL}-${RELEASE}}
93 93 PASSWORD=${PASSWORD:=raspberry}
94 94 USER_PASSWORD=${USER_PASSWORD:=raspberry}
95 95 DEFLOCAL=${DEFLOCAL:="en_US.UTF-8"}
96 96 TIMEZONE=${TIMEZONE:="Europe/Berlin"}
97 97 EXPANDROOT=${EXPANDROOT:=true}
98 98
99 99 # Keyboard settings
100 100 XKB_MODEL=${XKB_MODEL:=""}
101 101 XKB_LAYOUT=${XKB_LAYOUT:=""}
102 102 XKB_VARIANT=${XKB_VARIANT:=""}
103 103 XKB_OPTIONS=${XKB_OPTIONS:=""}
104 104
105 105 # Network settings (DHCP)
106 106 ENABLE_DHCP=${ENABLE_DHCP:=true}
107 107
108 108 # Network settings (static)
109 109 NET_ADDRESS=${NET_ADDRESS:=""}
110 110 NET_GATEWAY=${NET_GATEWAY:=""}
111 111 NET_DNS_1=${NET_DNS_1:=""}
112 112 NET_DNS_2=${NET_DNS_2:=""}
113 113 NET_DNS_DOMAINS=${NET_DNS_DOMAINS:=""}
114 114 NET_NTP_1=${NET_NTP_1:=""}
115 115 NET_NTP_2=${NET_NTP_2:=""}
116 116
117 117 # APT settings
118 118 APT_PROXY=${APT_PROXY:=""}
119 119 APT_SERVER=${APT_SERVER:="ftp.debian.org"}
120 120
121 121 # Feature settings
122 122 ENABLE_PRINTK=${ENABLE_PRINTK:=false}
123 123 ENABLE_BLUETOOTH=${ENABLE_BLUETOOTH:=false}
124 124 ENABLE_MINIUART_OVERLAY=${ENABLE_MINIUART_OVERLAY:=false}
125 125 ENABLE_CONSOLE=${ENABLE_CONSOLE:=true}
126 126 ENABLE_I2C=${ENABLE_I2C:=false}
127 127 ENABLE_SPI=${ENABLE_SPI:=false}
128 128 ENABLE_IPV6=${ENABLE_IPV6:=true}
129 129 ENABLE_SSHD=${ENABLE_SSHD:=true}
130 130 ENABLE_NONFREE=${ENABLE_NONFREE:=false}
131 131 ENABLE_WIRELESS=${ENABLE_WIRELESS:=false}
132 132 ENABLE_SOUND=${ENABLE_SOUND:=true}
133 133 ENABLE_DBUS=${ENABLE_DBUS:=true}
134 134 ENABLE_HWRANDOM=${ENABLE_HWRANDOM:=true}
135 135 ENABLE_MINGPU=${ENABLE_MINGPU:=false}
136 136 ENABLE_XORG=${ENABLE_XORG:=false}
137 137 ENABLE_WM=${ENABLE_WM:=""}
138 138 ENABLE_RSYSLOG=${ENABLE_RSYSLOG:=true}
139 139 ENABLE_USER=${ENABLE_USER:=true}
140 140 USER_NAME=${USER_NAME:="pi"}
141 141 ENABLE_ROOT=${ENABLE_ROOT:=false}
142 142 ENABLE_QEMU=${ENABLE_QEMU:=false}
143 143 ENABLE_SYSVINIT=${ENABLE_SYSVINIT:=false}
144 144
145 145 # SSH settings
146 146 SSH_ENABLE_ROOT=${SSH_ENABLE_ROOT:=false}
147 147 SSH_DISABLE_PASSWORD_AUTH=${SSH_DISABLE_PASSWORD_AUTH:=false}
148 148 SSH_LIMIT_USERS=${SSH_LIMIT_USERS:=false}
149 149 SSH_ROOT_PUB_KEY=${SSH_ROOT_PUB_KEY:=""}
150 150 SSH_USER_PUB_KEY=${SSH_USER_PUB_KEY:=""}
151 151
152 152 # Advanced settings
153 153 ENABLE_SYSTEMDSWAP=${ENABLE_MINBASE:=false}
154 154 ENABLE_MINBASE=${ENABLE_MINBASE:=false}
155 155 ENABLE_REDUCE=${ENABLE_REDUCE:=false}
156 156 ENABLE_UBOOT=${ENABLE_UBOOT:=false}
157 157 UBOOTSRC_DIR=${UBOOTSRC_DIR:=""}
158 158 ENABLE_UBOOTUSB=${ENABLE_UBOOTUSB=false}
159 159 ENABLE_FBTURBO=${ENABLE_FBTURBO:=false}
160 160 ENABLE_VIDEOCORE=${ENABLE_VIDEOCORE:=false}
161 161 ENABLE_NEXMON=${ENABLE_NEXMON:=false}
162 162 VIDEOCORESRC_DIR=${VIDEOCORESRC_DIR:=""}
163 163 FBTURBOSRC_DIR=${FBTURBOSRC_DIR:=""}
164 164 NEXMONSRC_DIR=${NEXMONSRC_DIR:=""}
165 165 ENABLE_HARDNET=${ENABLE_HARDNET:=false}
166 166 ENABLE_IPTABLES=${ENABLE_IPTABLES:=false}
167 167 ENABLE_SPLITFS=${ENABLE_SPLITFS:=false}
168 168 ENABLE_INITRAMFS=${ENABLE_INITRAMFS:=false}
169 169 ENABLE_IFNAMES=${ENABLE_IFNAMES:=true}
170 170 DISABLE_UNDERVOLT_WARNINGS=${DISABLE_UNDERVOLT_WARNINGS:=}
171 171
172 172 # Kernel compilation settings
173 173 BUILD_KERNEL=${BUILD_KERNEL:=true}
174 174 KERNEL_REDUCE=${KERNEL_REDUCE:=false}
175 175 KERNEL_THREADS=${KERNEL_THREADS:=1}
176 176 KERNEL_HEADERS=${KERNEL_HEADERS:=true}
177 177 KERNEL_MENUCONFIG=${KERNEL_MENUCONFIG:=false}
178 178 KERNEL_REMOVESRC=${KERNEL_REMOVESRC:=true}
179 179 KERNEL_OLDDEFCONFIG=${KERNEL_OLDDEFCONFIG:=false}
180 180 KERNEL_CCACHE=${KERNEL_CCACHE:=false}
181 181 KERNEL_ZSWAP=${KERNEL_ZSWAP:=false}
182 182 KERNEL_VIRT=${KERNEL_VIRT:=false}
183 183 KERNEL_BPF=${KERNEL_BPF:=false}
184 184 KERNEL_DEFAULT_GOV=${KERNEL_DEFAULT_GOV:=POWERSAVE}
185 185
186 186 # Kernel compilation from source directory settings
187 187 KERNELSRC_DIR=${KERNELSRC_DIR:=""}
188 188 KERNELSRC_CLEAN=${KERNELSRC_CLEAN:=false}
189 189 KERNELSRC_CONFIG=${KERNELSRC_CONFIG:=true}
190 190 KERNELSRC_PREBUILT=${KERNELSRC_PREBUILT:=false}
191 191
192 192 # Reduce disk usage settings
193 193 REDUCE_APT=${REDUCE_APT:=true}
194 194 REDUCE_DOC=${REDUCE_DOC:=true}
195 195 REDUCE_MAN=${REDUCE_MAN:=true}
196 196 REDUCE_VIM=${REDUCE_VIM:=false}
197 197 REDUCE_BASH=${REDUCE_BASH:=false}
198 198 REDUCE_HWDB=${REDUCE_HWDB:=true}
199 199 REDUCE_SSHD=${REDUCE_SSHD:=true}
200 200 REDUCE_LOCALE=${REDUCE_LOCALE:=true}
201 201
202 202 # Encrypted filesystem settings
203 203 ENABLE_CRYPTFS=${ENABLE_CRYPTFS:=false}
204 204 CRYPTFS_PASSWORD=${CRYPTFS_PASSWORD:=""}
205 205 CRYPTFS_MAPPING=${CRYPTFS_MAPPING:="secure"}
206 206 CRYPTFS_CIPHER=${CRYPTFS_CIPHER:="aes-xts-plain64:sha512"}
207 207 CRYPTFS_XTSKEYSIZE=${CRYPTFS_XTSKEYSIZE:=512}
208 208 #Dropbear-initramfs supports unlocking encrypted filesystem via SSH on bootup
209 209 CRYPTFS_DROPBEAR=${CRYPTFS_DROPBEAR:=false}
210 210 #Provide your own Dropbear Public RSA-OpenSSH Key otherwise it will be generated
211 211 CRYPTFS_DROPBEAR_PUBKEY=${CRYPTFS_DROPBEAR_PUBKEY:=""}
212 212
213 213 # Chroot scripts directory
214 214 CHROOT_SCRIPTS=${CHROOT_SCRIPTS:=""}
215 215
216 216 # Packages required in the chroot build environment
217 217 APT_INCLUDES=${APT_INCLUDES:=""}
218 218 APT_INCLUDES="${APT_INCLUDES},apt-transport-https,apt-utils,ca-certificates,debian-archive-keyring,dialog,sudo,systemd,sysvinit-utils,locales,keyboard-configuration,console-setup,libnss-systemd"
219 219
220 220 #Packages to exclude from chroot build environment
221 221 APT_EXCLUDES=${APT_EXCLUDES:=""}
222 222
223 223 # Packages required for bootstrapping
224 224 REQUIRED_PACKAGES="debootstrap debian-archive-keyring qemu-user-static binfmt-support dosfstools rsync bmap-tools whois git bc psmisc dbus sudo netselect-apt"
225 225 MISSING_PACKAGES=""
226 226
227 227 # Packages installed for c/c++ build environment in chroot (keep empty)
228 228 COMPILER_PACKAGES=""
229 229
230 230 #Check if apt-cacher-ng has port 3142 open and set APT_PROXY
231 231 APT_CACHER_RUNNING=$(lsof -i :3142 | cut -d ' ' -f3 | uniq | sed '/^\s*$/d')
232 232 if [ "${APT_CACHER_RUNNING}" = "apt-cacher-ng" ] ; then
233 233 APT_PROXY=http://127.0.0.1:3142/
234 234 fi
235 235
236 236 #netselect-apt does not know buster yet
237 237 if [ "$RELEASE" = "buster" ] ; then
238 238 RLS=testing
239 239 else
240 240 RLS="$RELEASE"
241 241 fi
242 242
243 243 if [ -f "$(pwd)/files/apt/sources.list" ] ; then
244 244 rm "$(pwd)/files/apt/sources.list"
245 245 fi
246 246
247 247 if [ "$ENABLE_NONFREE" = true ] ; then
248 248 netselect-apt --arch "$RELEASE_ARCH" -t 3 --sources --nonfree --outfile "$(pwd)/files/apt/sources.list" -d "$RLS"
249 249 else
250 250 netselect-apt --arch "$RELEASE_ARCH" -t 3 --sources --outfile "$(pwd)/files/apt/sources.list" -d "$RLS"
251 251 fi
252 252
253 253 #sed and cut the result string so we can use it as APT_SERVER
254 254 APT_SERVER=$(grep -m 1 http files/apt/sources.list | sed "s|http://| |g" | cut -d ' ' -f 3 | sed 's|/$|''|')
255 255
256 256 #make script easier and more stable to use with convenient setup switch. Just setup SET_ARCH and RPI_MODEL and your good to go!
257 257 if [ -n "$SET_ARCH" ] ; then
258 258 # 64-bit configuration
259 259 if [ "$SET_ARCH" = 64 ] ; then
260 260 # General 64-bit depended settings
261 261 QEMU_BINARY=${QEMU_BINARY:=/usr/bin/qemu-aarch64-static}
262 262 KERNEL_ARCH=${KERNEL_ARCH:=arm64}
263 263 KERNEL_BIN_IMAGE=${KERNEL_BIN_IMAGE:="Image"}
264 264
265 265 # Raspberry Pi model specific settings
266 266 if [ "$RPI_MODEL" = 3 ] || [ "$RPI_MODEL" = 3P ] ; then
267 267 REQUIRED_PACKAGES="${REQUIRED_PACKAGES} crossbuild-essential-arm64"
268 268 KERNEL_DEFCONFIG=${KERNEL_DEFCONFIG:=bcmrpi3_defconfig}
269 269 RELEASE_ARCH=${RELEASE_ARCH:=arm64}
270 270 KERNEL_IMAGE=${KERNEL_IMAGE:=kernel8.img}
271 271 CROSS_COMPILE=${CROSS_COMPILE:=aarch64-linux-gnu-}
272 272 else
273 273 echo "error: Only Raspberry PI 3 and 3B+ support 64-bit"
274 274 exit 1
275 275 fi
276 276 fi
277 277
278 278 # 32-bit configuration
279 279 if [ "$SET_ARCH" = 32 ] ; then
280 280 # General 32-bit dependend settings
281 281 QEMU_BINARY=${QEMU_BINARY:=/usr/bin/qemu-arm-static}
282 282 KERNEL_ARCH=${KERNEL_ARCH:=arm}
283 283 KERNEL_BIN_IMAGE=${KERNEL_BIN_IMAGE:="zImage"}
284 284
285 285 # Raspberry Pi model specific settings
286 286 if [ "$RPI_MODEL" = 0 ] || [ "$RPI_MODEL" = 1 ] || [ "$RPI_MODEL" = 1P ] ; then
287 287 REQUIRED_PACKAGES="${REQUIRED_PACKAGES} crossbuild-essential-armel"
288 288 KERNEL_DEFCONFIG=${KERNEL_DEFCONFIG:=bcmrpi_defconfig}
289 289 RELEASE_ARCH=${RELEASE_ARCH:=armel}
290 290 KERNEL_IMAGE=${KERNEL_IMAGE:=kernel.img}
291 291 CROSS_COMPILE=${CROSS_COMPILE:=arm-linux-gnueabi-}
292 292 fi
293 293
294 294 # Raspberry Pi model specific settings
295 295 if [ "$RPI_MODEL" = 2 ] || [ "$RPI_MODEL" = 3 ] || [ "$RPI_MODEL" = 3P ] ; then
296 296 REQUIRED_PACKAGES="${REQUIRED_PACKAGES} crossbuild-essential-armhf"
297 297 KERNEL_DEFCONFIG=${KERNEL_DEFCONFIG:=bcm2709_defconfig}
298 298 RELEASE_ARCH=${RELEASE_ARCH:=armhf}
299 299 KERNEL_IMAGE=${KERNEL_IMAGE:=kernel7.img}
300 300 CROSS_COMPILE=${CROSS_COMPILE:=arm-linux-gnueabihf-}
301 301 fi
302 302 fi
303 303 #SET_ARCH not set
304 304 else
305 305 echo "error: Please set '32' or '64' as value for SET_ARCH"
306 306 exit 1
307 307 fi
308 308 # Device specific configuration and U-Boot configuration
309 309 case "$RPI_MODEL" in
310 310 0)
311 311 DTB_FILE=${DTB_FILE:=bcm2708-rpi-0-w.dtb}
312 312 UBOOT_CONFIG=${UBOOT_CONFIG:=rpi_defconfig}
313 313 ;;
314 314 1)
315 315 DTB_FILE=${DTB_FILE:=bcm2708-rpi-b.dtb}
316 316 UBOOT_CONFIG=${UBOOT_CONFIG:=rpi_defconfig}
317 317 ;;
318 318 1P)
319 319 DTB_FILE=${DTB_FILE:=bcm2708-rpi-b-plus.dtb}
320 320 UBOOT_CONFIG=${UBOOT_CONFIG:=rpi_defconfig}
321 321 ;;
322 322 2)
323 323 DTB_FILE=${DTB_FILE:=bcm2709-rpi-2-b.dtb}
324 324 UBOOT_CONFIG=${UBOOT_CONFIG:=rpi_2_defconfig}
325 325 ;;
326 326 3)
327 327 DTB_FILE=${DTB_FILE:=bcm2710-rpi-3-b.dtb}
328 328 UBOOT_CONFIG=${UBOOT_CONFIG:=rpi_3_defconfig}
329 329 ;;
330 330 3P)
331 331 DTB_FILE=${DTB_FILE:=bcm2710-rpi-3-b.dtb}
332 332 UBOOT_CONFIG=${UBOOT_CONFIG:=rpi_3_defconfig}
333 333 ;;
334 334 *)
335 335 echo "error: Raspberry Pi model $RPI_MODEL is not supported!"
336 336 exit 1
337 337 ;;
338 338 esac
339 339
340 340 # Raspberry PI 0,3,3P with Bluetooth and Wifi onboard
341 341 if [ "$RPI_MODEL" = 0 ] || [ "$RPI_MODEL" = 3 ] || [ "$RPI_MODEL" = 3P ] ; then
342 342 # Include bluetooth packages on supported boards
343 343 if [ "$ENABLE_BLUETOOTH" = true ] && [ "$ENABLE_CONSOLE" = false ]; then
344 344 APT_INCLUDES="${APT_INCLUDES},bluetooth,bluez"
345 345 fi
346 346 else # Raspberry PI 1,1P,2 without Wifi and bluetooth onboard
347 347 # Check if the internal wireless interface is not supported by the RPi model
348 348 if [ "$ENABLE_WIRELESS" = true ] || [ "$ENABLE_BLUETOOTH" = true ]; then
349 349 echo "error: The selected Raspberry Pi model has no integrated interface for wireless or bluetooth"
350 350 exit 1
351 351 fi
352 352 fi
353 353
354 if [ "$BUILD_KERNEL" = false ] && [ "$ENABLE_NEXMON" = true ]; then
355 echo "error: You have to compile kernel sources, if you want to enable nexmon"
356 exit 1
357 fi
358
354 359 # Prepare date string for default image file name
355 360 DATE="$(date +%Y-%m-%d)"
356 361 if [ -z "$KERNEL_BRANCH" ] ; then
357 362 IMAGE_NAME=${IMAGE_NAME:=${BASEDIR}/${DATE}-${KERNEL_ARCH}-CURRENT-rpi${RPI_MODEL}-${RELEASE}-${RELEASE_ARCH}}
358 363 else
359 364 IMAGE_NAME=${IMAGE_NAME:=${BASEDIR}/${DATE}-${KERNEL_ARCH}-${KERNEL_BRANCH}-rpi${RPI_MODEL}-${RELEASE}-${RELEASE_ARCH}}
360 365 fi
361 366
362 367 # Check if DISABLE_UNDERVOLT_WARNINGS parameter value is supported
363 368 if [ -n "$DISABLE_UNDERVOLT_WARNINGS" ] ; then
364 369 if [ "$DISABLE_UNDERVOLT_WARNINGS" != 1 ] && [ "$DISABLE_UNDERVOLT_WARNINGS" != 2 ] ; then
365 370 echo "error: DISABLE_UNDERVOLT_WARNINGS=${DISABLE_UNDERVOLT_WARNINGS} is not supported"
366 371 exit 1
367 372 fi
368 373 fi
369 374
370 375 set +x
371 376
372 377 # Add cmake to compile videocore sources
373 378 if [ "$ENABLE_VIDEOCORE" = true ] ; then
374 379 REQUIRED_PACKAGES="${REQUIRED_PACKAGES} cmake"
375 380 fi
376 381
377 382 # Add deps for nexmon
378 383 if [ "$ENABLE_NEXMON" = true ] ; then
379 384 REQUIRED_PACKAGES="${REQUIRED_PACKAGES} libgmp3-dev gawk qpdf bison flex make autoconf automake build-essential libtool"
380 385 fi
381 386
382 387 # Add libncurses5 to enable kernel menuconfig
383 388 if [ "$KERNEL_MENUCONFIG" = true ] ; then
384 389 REQUIRED_PACKAGES="${REQUIRED_PACKAGES} libncurses-dev"
385 390 fi
386 391
387 392 # Add ccache compiler cache for (faster) kernel cross (re)compilation
388 393 if [ "$KERNEL_CCACHE" = true ] ; then
389 394 REQUIRED_PACKAGES="${REQUIRED_PACKAGES} ccache"
390 395 fi
391 396
392 397 # Add cryptsetup package to enable filesystem encryption
393 398 if [ "$ENABLE_CRYPTFS" = true ] && [ "$BUILD_KERNEL" = true ] ; then
394 399 REQUIRED_PACKAGES="${REQUIRED_PACKAGES} cryptsetup"
395 400 APT_INCLUDES="${APT_INCLUDES},cryptsetup,busybox,console-setup"
396 401
397 402 #If cryptfs,dropbear and initramfs are enabled include dropbear-initramfs package
398 403 if [ "$CRYPTFS_DROPBEAR" = true ] && [ "$ENABLE_INITRAMFS" = true ]; then
399 404 APT_INCLUDES="${APT_INCLUDES},dropbear-initramfs"
400 405 fi
401 406
402 407 if [ -z "$CRYPTFS_PASSWORD" ] ; then
403 408 echo "error: no password defined (CRYPTFS_PASSWORD)!"
404 409 exit 1
405 410 fi
406 411 ENABLE_INITRAMFS=true
407 412 fi
408 413
409 414 # Add initramfs generation tools
410 415 if [ "$ENABLE_INITRAMFS" = true ] && [ "$BUILD_KERNEL" = true ] ; then
411 416 APT_INCLUDES="${APT_INCLUDES},initramfs-tools"
412 417 fi
413 418
414 419 # Add device-tree-compiler required for building the U-Boot bootloader
415 420 if [ "$ENABLE_UBOOT" = true ] ; then
416 421 APT_INCLUDES="${APT_INCLUDES},device-tree-compiler,bison,flex,bc"
417 422 else
418 423 if [ "$ENABLE_UBOOTUSB" = true ] ; then
419 424 echo "error: Enabling UBOOTUSB requires u-boot to be enabled"
420 425 exit 1
421 426 fi
422 427 fi
423 428
424 429 if [ "$ENABLE_BLUETOOTH" = true ] ; then
425 430 if [ "$RPI_MODEL" = 0 ] || [ "$RPI_MODEL" = 3 ] || [ "$RPI_MODEL" = 3P ] ; then
426 431 if [ "$ENABLE_CONSOLE" = false ] ; then
427 432 APT_INCLUDES="${APT_INCLUDES},bluetooth,bluez"
428 433 fi
429 434 fi
430 435 fi
431 436
432 437 # Check if root SSH (v2) public key file exists
433 438 if [ -n "$SSH_ROOT_PUB_KEY" ] ; then
434 439 if [ ! -f "$SSH_ROOT_PUB_KEY" ] ; then
435 440 echo "error: '$SSH_ROOT_PUB_KEY' specified SSH public key file not found (SSH_ROOT_PUB_KEY)!"
436 441 exit 1
437 442 fi
438 443 fi
439 444
440 445 # Check if $USER_NAME SSH (v2) public key file exists
441 446 if [ -n "$SSH_USER_PUB_KEY" ] ; then
442 447 if [ ! -f "$SSH_USER_PUB_KEY" ] ; then
443 448 echo "error: '$SSH_USER_PUB_KEY' specified SSH public key file not found (SSH_USER_PUB_KEY)!"
444 449 exit 1
445 450 fi
446 451 fi
447 452
448 453 # Check if all required packages are installed on the build system
449 454 for package in $REQUIRED_PACKAGES ; do
450 455 if [ "$(dpkg-query -W -f='${Status}' "$package")" != "install ok installed" ] ; then
451 456 MISSING_PACKAGES="${MISSING_PACKAGES} $package"
452 457 fi
453 458 done
454 459
455 460 # If there are missing packages ask confirmation for install, or exit
456 461 if [ -n "$MISSING_PACKAGES" ] ; then
457 462 echo "the following packages needed by this script are not installed:"
458 463 echo "$MISSING_PACKAGES"
459 464
460 465 printf "\ndo you want to install the missing packages right now? [y/n] "
461 466 read -r confirm
462 467 [ "$confirm" != "y" ] && exit 1
463 468
464 469 # Make sure all missing required packages are installed
465 470 apt-get -qq -y install `echo "${MISSING_PACKAGES}" | sed "s/ //"`
466 471 fi
467 472
468 473 # Check if ./bootstrap.d directory exists
469 474 if [ ! -d "./bootstrap.d/" ] ; then
470 475 echo "error: './bootstrap.d' required directory not found!"
471 476 exit 1
472 477 fi
473 478
474 479 # Check if ./files directory exists
475 480 if [ ! -d "./files/" ] ; then
476 481 echo "error: './files' required directory not found!"
477 482 exit 1
478 483 fi
479 484
480 485 # Check if specified KERNELSRC_DIR directory exists
481 486 if [ -n "$KERNELSRC_DIR" ] && [ ! -d "$KERNELSRC_DIR" ] ; then
482 487 echo "error: '${KERNELSRC_DIR}' specified directory not found (KERNELSRC_DIR)!"
483 488 exit 1
484 489 fi
485 490
486 491 # Check if specified UBOOTSRC_DIR directory exists
487 492 if [ -n "$UBOOTSRC_DIR" ] && [ ! -d "$UBOOTSRC_DIR" ] ; then
488 493 echo "error: '${UBOOTSRC_DIR}' specified directory not found (UBOOTSRC_DIR)!"
489 494 exit 1
490 495 fi
491 496
492 497 # Check if specified VIDEOCORESRC_DIR directory exists
493 498 if [ -n "$VIDEOCORESRC_DIR" ] && [ ! -d "$VIDEOCORESRC_DIR" ] ; then
494 499 echo "error: '${VIDEOCORESRC_DIR}' specified directory not found (VIDEOCORESRC_DIR)!"
495 500 exit 1
496 501 fi
497 502
498 503 # Check if specified FBTURBOSRC_DIR directory exists
499 504 if [ -n "$FBTURBOSRC_DIR" ] && [ ! -d "$FBTURBOSRC_DIR" ] ; then
500 505 echo "error: '${FBTURBOSRC_DIR}' specified directory not found (FBTURBOSRC_DIR)!"
501 506 exit 1
502 507 fi
503 508
504 509 # Check if specified NEXMONSRC_DIR directory exists
505 510 if [ -n "$NEXMONSRC_DIR" ] && [ ! -d "$NEXMONSRC_DIR" ] ; then
506 511 echo "error: '${NEXMONSRC_DIR}' specified directory not found (NEXMONSRC_DIR)!"
507 512 exit 1
508 513 fi
509 514
510 515 # Check if specified CHROOT_SCRIPTS directory exists
511 516 if [ -n "$CHROOT_SCRIPTS" ] && [ ! -d "$CHROOT_SCRIPTS" ] ; then
512 517 echo "error: ${CHROOT_SCRIPTS} specified directory not found (CHROOT_SCRIPTS)!"
513 518 exit 1
514 519 fi
515 520
516 521 # Check if specified device mapping already exists (will be used by cryptsetup)
517 522 if [ -r "/dev/mapping/${CRYPTFS_MAPPING}" ] ; then
518 523 echo "error: mapping /dev/mapping/${CRYPTFS_MAPPING} already exists, not proceeding"
519 524 exit 1
520 525 fi
521 526
522 527 # Don't clobber an old build
523 528 if [ -e "$BUILDDIR" ] ; then
524 529 echo "error: directory ${BUILDDIR} already exists, not proceeding"
525 530 exit 1
526 531 fi
527 532
528 533 # Setup chroot directory
529 534 mkdir -p "${R}"
530 535
531 536 # Check if build directory has enough of free disk space >512MB
532 537 if [ "$(df --output=avail "${BUILDDIR}" | sed "1d")" -le "524288" ] ; then
533 538 echo "error: ${BUILDDIR} not enough space left to generate the output image!"
534 539 exit 1
535 540 fi
536 541
537 542 set -x
538 543
539 544 # Call "cleanup" function on various signals and errors
540 545 trap cleanup 0 1 2 3 6
541 546
542 547 # Add required packages for the minbase installation
543 548 if [ "$ENABLE_MINBASE" = true ] ; then
544 549 APT_INCLUDES="${APT_INCLUDES},vim-tiny,netbase,net-tools,ifupdown"
545 550 fi
546 551
547 552 # Add parted package, required to get partprobe utility
548 553 if [ "$EXPANDROOT" = true ] ; then
549 554 APT_INCLUDES="${APT_INCLUDES},parted"
550 555 fi
551 556
552 557 # Add dbus package, recommended if using systemd
553 558 if [ "$ENABLE_DBUS" = true ] ; then
554 559 APT_INCLUDES="${APT_INCLUDES},dbus"
555 560 fi
556 561
557 562 # Add iptables IPv4/IPv6 package
558 563 if [ "$ENABLE_IPTABLES" = true ] ; then
559 564 APT_INCLUDES="${APT_INCLUDES},iptables,iptables-persistent"
560 565 fi
561 566
562 567 # Add openssh server package
563 568 if [ "$ENABLE_SSHD" = true ] ; then
564 569 APT_INCLUDES="${APT_INCLUDES},openssh-server"
565 570 fi
566 571
567 572 # Add alsa-utils package
568 573 if [ "$ENABLE_SOUND" = true ] ; then
569 574 APT_INCLUDES="${APT_INCLUDES},alsa-utils"
570 575 fi
571 576
572 577 # Add rng-tools package
573 578 if [ "$ENABLE_HWRANDOM" = true ] ; then
574 579 APT_INCLUDES="${APT_INCLUDES},rng-tools"
575 580 fi
576 581
577 582 # Add fbturbo video driver
578 583 if [ "$ENABLE_FBTURBO" = true ] ; then
579 584 # Enable xorg package dependencies
580 585 ENABLE_XORG=true
581 586 fi
582 587
583 588 # Add user defined window manager package
584 589 if [ -n "$ENABLE_WM" ] ; then
585 590 APT_INCLUDES="${APT_INCLUDES},${ENABLE_WM}"
586 591
587 592 # Enable xorg package dependencies
588 593 ENABLE_XORG=true
589 594 fi
590 595
591 596 # Add xorg package
592 597 if [ "$ENABLE_XORG" = true ] ; then
593 598 APT_INCLUDES="${APT_INCLUDES},xorg,dbus-x11"
594 599 fi
595 600
596 601 # Replace selected packages with smaller clones
597 602 if [ "$ENABLE_REDUCE" = true ] ; then
598 603 # Add levee package instead of vim-tiny
599 604 if [ "$REDUCE_VIM" = true ] ; then
600 605 APT_INCLUDES="$(echo ${APT_INCLUDES} | sed "s/vim-tiny/levee/")"
601 606 fi
602 607
603 608 # Add dropbear package instead of openssh-server
604 609 if [ "$REDUCE_SSHD" = true ] ; then
605 610 APT_INCLUDES="$(echo "${APT_INCLUDES}" | sed "s/openssh-server/dropbear/")"
606 611 fi
607 612 fi
608 613
609 614 # Configure systemd-sysv exclude to make halt/reboot/shutdown scripts available
610 615 if [ "$ENABLE_SYSVINIT" = false ] ; then
611 616 APT_EXCLUDES="--exclude=${APT_EXCLUDES},init,systemd-sysv"
612 617 fi
613 618
614 619 # Configure kernel sources if no KERNELSRC_DIR
615 620 if [ "$BUILD_KERNEL" = true ] && [ -z "$KERNELSRC_DIR" ] ; then
616 621 KERNELSRC_CONFIG=true
617 622 fi
618 623
619 624 # Configure reduced kernel
620 625 if [ "$KERNEL_REDUCE" = true ] ; then
621 626 KERNELSRC_CONFIG=false
622 627 fi
623 628
624 629 # Configure qemu compatible kernel
625 630 if [ "$ENABLE_QEMU" = true ] ; then
626 631 DTB_FILE=vexpress-v2p-ca15_a7.dtb
627 632 UBOOT_CONFIG=vexpress_ca15_tc2_defconfig
628 633 KERNEL_DEFCONFIG="vexpress_defconfig"
629 634 if [ "$KERNEL_MENUCONFIG" = false ] ; then
630 635 KERNEL_OLDDEFCONFIG=true
631 636 fi
632 637 fi
633 638
634 639 # Execute bootstrap scripts
635 640 for SCRIPT in bootstrap.d/*.sh; do
636 641 head -n 3 "$SCRIPT"
637 642 . "$SCRIPT"
638 643 done
639 644
640 645 ## Execute custom bootstrap scripts
641 646 if [ -d "custom.d" ] ; then
642 647 for SCRIPT in custom.d/*.sh; do
643 648 . "$SCRIPT"
644 649 done
645 650 fi
646 651
647 652 # Execute custom scripts inside the chroot
648 653 if [ -n "$CHROOT_SCRIPTS" ] && [ -d "$CHROOT_SCRIPTS" ] ; then
649 654 cp -r "${CHROOT_SCRIPTS}" "${R}/chroot_scripts"
650 655 chroot_exec /bin/bash -x <<'EOF'
651 656 for SCRIPT in /chroot_scripts/* ; do
652 657 if [ -f $SCRIPT -a -x $SCRIPT ] ; then
653 658 $SCRIPT
654 659 fi
655 660 done
656 661 EOF
657 662 rm -rf "${R}/chroot_scripts"
658 663 fi
659 664
660 665 # Remove c/c++ build environment from the chroot
661 666 chroot_remove_cc
662 667
663 668 # Generate required machine-id
664 669 MACHINE_ID=$(dbus-uuidgen)
665 670 echo -n "${MACHINE_ID}" > "${R}/var/lib/dbus/machine-id"
666 671 echo -n "${MACHINE_ID}" > "${ETC_DIR}/machine-id"
667 672
668 673 # APT Cleanup
669 674 chroot_exec apt-get -y clean
670 675 chroot_exec apt-get -y autoclean
671 676 chroot_exec apt-get -y autoremove
672 677
673 678 # Unmount mounted filesystems
674 679 umount -l "${R}/proc"
675 680 umount -l "${R}/sys"
676 681
677 682 # Clean up directories
678 683 rm -rf "${R}/run/*"
679 684 rm -rf "${R}/tmp/*"
680 685
681 686 # Clean up files
682 687 rm -f "${ETC_DIR}/ssh/ssh_host_*"
683 688 rm -f "${ETC_DIR}/dropbear/dropbear_*"
684 689 rm -f "${ETC_DIR}/apt/sources.list.save"
685 690 rm -f "${ETC_DIR}/resolvconf/resolv.conf.d/original"
686 691 rm -f "${ETC_DIR}/*-"
687 692 rm -f "${ETC_DIR}/apt/apt.conf.d/10proxy"
688 693 rm -f "${ETC_DIR}/resolv.conf"
689 694 rm -f "${R}/root/.bash_history"
690 695 rm -f "${R}/var/lib/urandom/random-seed"
691 696 rm -f "${R}/initrd.img"
692 697 rm -f "${R}/vmlinuz"
693 698 rm -f "${R}${QEMU_BINARY}"
694 699
695 700 if [ "$ENABLE_QEMU" = true ] ; then
696 701 # Setup QEMU directory
697 702 mkdir "${BASEDIR}/qemu"
698 703
699 704 # Copy kernel image to QEMU directory
700 705 install_readonly "${BOOT_DIR}/${KERNEL_IMAGE}" "${BASEDIR}/qemu/${KERNEL_IMAGE}"
701 706
702 707 # Copy kernel config to QEMU directory
703 708 install_readonly "${R}/boot/config-${KERNEL_VERSION}" "${BASEDIR}/qemu/config-${KERNEL_VERSION}"
704 709
705 710 # Copy kernel dtbs to QEMU directory
706 711 for dtb in "${BOOT_DIR}/"*.dtb ; do
707 712 if [ -f "${dtb}" ] ; then
708 713 install_readonly "${dtb}" "${BASEDIR}/qemu/"
709 714 fi
710 715 done
711 716
712 717 # Copy kernel overlays to QEMU directory
713 718 if [ -d "${BOOT_DIR}/overlays" ] ; then
714 719 # Setup overlays dtbs directory
715 720 mkdir "${BASEDIR}/qemu/overlays"
716 721
717 722 for dtb in "${BOOT_DIR}/overlays/"*.dtb ; do
718 723 if [ -f "${dtb}" ] ; then
719 724 install_readonly "${dtb}" "${BASEDIR}/qemu/overlays/"
720 725 fi
721 726 done
722 727 fi
723 728
724 729 # Copy u-boot files to QEMU directory
725 730 if [ "$ENABLE_UBOOT" = true ] ; then
726 731 if [ -f "${BOOT_DIR}/u-boot.bin" ] ; then
727 732 install_readonly "${BOOT_DIR}/u-boot.bin" "${BASEDIR}/qemu/u-boot.bin"
728 733 fi
729 734 if [ -f "${BOOT_DIR}/uboot.mkimage" ] ; then
730 735 install_readonly "${BOOT_DIR}/uboot.mkimage" "${BASEDIR}/qemu/uboot.mkimage"
731 736 fi
732 737 if [ -f "${BOOT_DIR}/boot.scr" ] ; then
733 738 install_readonly "${BOOT_DIR}/boot.scr" "${BASEDIR}/qemu/boot.scr"
734 739 fi
735 740 fi
736 741
737 742 # Copy initramfs to QEMU directory
738 743 if [ -f "${BOOT_DIR}/initramfs-${KERNEL_VERSION}" ] ; then
739 744 install_readonly "${BOOT_DIR}/initramfs-${KERNEL_VERSION}" "${BASEDIR}/qemu/initramfs-${KERNEL_VERSION}"
740 745 fi
741 746 fi
742 747
743 748 # Calculate size of the chroot directory in KB
744 749 CHROOT_SIZE=$(expr "$(du -s "${R}" | awk '{ print $1 }')")
745 750
746 751 # Calculate the amount of needed 512 Byte sectors
747 752 TABLE_SECTORS=$(expr 1 \* 1024 \* 1024 \/ 512)
748 753 FRMW_SECTORS=$(expr 64 \* 1024 \* 1024 \/ 512)
749 754 ROOT_OFFSET=$(expr "${TABLE_SECTORS}" + "${FRMW_SECTORS}")
750 755
751 756 # The root partition is EXT4
752 757 # This means more space than the actual used space of the chroot is used.
753 758 # As overhead for journaling and reserved blocks 35% are added.
754 759 ROOT_SECTORS=$(expr "$(expr "${CHROOT_SIZE}" + "${CHROOT_SIZE}" \/ 100 \* 35)" \* 1024 \/ 512)
755 760
756 761 # Calculate required image size in 512 Byte sectors
757 762 IMAGE_SECTORS=$(expr "${TABLE_SECTORS}" + "${FRMW_SECTORS}" + "${ROOT_SECTORS}")
758 763
759 764 # Prepare image file
760 765 if [ "$ENABLE_SPLITFS" = true ] ; then
761 766 dd if=/dev/zero of="$IMAGE_NAME-frmw.img" bs=512 count="${TABLE_SECTORS}"
762 767 dd if=/dev/zero of="$IMAGE_NAME-frmw.img" bs=512 count=0 seek="${FRMW_SECTORS}"
763 768 dd if=/dev/zero of="$IMAGE_NAME-root.img" bs=512 count="${TABLE_SECTORS}"
764 769 dd if=/dev/zero of="$IMAGE_NAME-root.img" bs=512 count=0 seek="${ROOT_SECTORS}"
765 770
766 771 # Write firmware/boot partition tables
767 772 sfdisk -q -L -uS -f "$IMAGE_NAME-frmw.img" 2> /dev/null <<EOM
768 773 ${TABLE_SECTORS},${FRMW_SECTORS},c,*
769 774 EOM
770 775
771 776 # Write root partition table
772 777 sfdisk -q -L -uS -f "$IMAGE_NAME-root.img" 2> /dev/null <<EOM
773 778 ${TABLE_SECTORS},${ROOT_SECTORS},83
774 779 EOM
775 780
776 781 # Setup temporary loop devices
777 782 FRMW_LOOP="$(losetup -o 1M --sizelimit 64M -f --show "$IMAGE_NAME"-frmw.img)"
778 783 ROOT_LOOP="$(losetup -o 1M -f --show "$IMAGE_NAME"-root.img)"
779 784 else # ENABLE_SPLITFS=false
780 785 dd if=/dev/zero of="$IMAGE_NAME.img" bs=512 count="${TABLE_SECTORS}"
781 786 dd if=/dev/zero of="$IMAGE_NAME.img" bs=512 count=0 seek="${IMAGE_SECTORS}"
782 787
783 788 # Write partition table
784 789 sfdisk -q -L -uS -f "$IMAGE_NAME.img" 2> /dev/null <<EOM
785 790 ${TABLE_SECTORS},${FRMW_SECTORS},c,*
786 791 ${ROOT_OFFSET},${ROOT_SECTORS},83
787 792 EOM
788 793
789 794 # Setup temporary loop devices
790 795 FRMW_LOOP="$(losetup -o 1M --sizelimit 64M -f --show "$IMAGE_NAME".img)"
791 796 ROOT_LOOP="$(losetup -o 65M -f --show "$IMAGE_NAME".img)"
792 797 fi
793 798
794 799 if [ "$ENABLE_CRYPTFS" = true ] ; then
795 800 # Create dummy ext4 fs
796 801 mkfs.ext4 "$ROOT_LOOP"
797 802
798 803 # Setup password keyfile
799 804 touch .password
800 805 chmod 600 .password
801 806 echo -n ${CRYPTFS_PASSWORD} > .password
802 807
803 808 # Initialize encrypted partition
804 809 echo "YES" | cryptsetup luksFormat "${ROOT_LOOP}" -c "${CRYPTFS_CIPHER}" -s "${CRYPTFS_XTSKEYSIZE}" .password
805 810
806 811 # Open encrypted partition and setup mapping
807 812 cryptsetup luksOpen "${ROOT_LOOP}" -d .password "${CRYPTFS_MAPPING}"
808 813
809 814 # Secure delete password keyfile
810 815 shred -zu .password
811 816
812 817 # Update temporary loop device
813 818 ROOT_LOOP="/dev/mapper/${CRYPTFS_MAPPING}"
814 819
815 820 # Wipe encrypted partition (encryption cipher is used for randomness)
816 821 dd if=/dev/zero of="${ROOT_LOOP}" bs=512 count="$(blockdev --getsz "${ROOT_LOOP}")"
817 822 fi
818 823
819 824 # Build filesystems
820 825 mkfs.vfat "$FRMW_LOOP"
821 826 mkfs.ext4 "$ROOT_LOOP"
822 827
823 828 # Mount the temporary loop devices
824 829 mkdir -p "$BUILDDIR/mount"
825 830 mount "$ROOT_LOOP" "$BUILDDIR/mount"
826 831
827 832 mkdir -p "$BUILDDIR/mount/boot/firmware"
828 833 mount "$FRMW_LOOP" "$BUILDDIR/mount/boot/firmware"
829 834
830 835 # Copy all files from the chroot to the loop device mount point directory
831 836 rsync -a "${R}/" "$BUILDDIR/mount/"
832 837
833 838 # Unmount all temporary loop devices and mount points
834 839 cleanup
835 840
836 841 # Create block map file(s) of image(s)
837 842 if [ "$ENABLE_SPLITFS" = true ] ; then
838 843 # Create block map files for "bmaptool"
839 844 bmaptool create -o "$IMAGE_NAME-frmw.bmap" "$IMAGE_NAME-frmw.img"
840 845 bmaptool create -o "$IMAGE_NAME-root.bmap" "$IMAGE_NAME-root.img"
841 846
842 847 # Image was successfully created
843 848 echo "$IMAGE_NAME-frmw.img ($(expr \( "${TABLE_SECTORS}" + "${FRMW_SECTORS}" \) \* 512 \/ 1024 \/ 1024)M)" ": successfully created"
844 849 echo "$IMAGE_NAME-root.img ($(expr \( "${TABLE_SECTORS}" + "${ROOT_SECTORS}" \) \* 512 \/ 1024 \/ 1024)M)" ": successfully created"
845 850 else
846 851 # Create block map file for "bmaptool"
847 852 bmaptool create -o "$IMAGE_NAME.bmap" "$IMAGE_NAME.img"
848 853
849 854 # Image was successfully created
850 855 echo "$IMAGE_NAME.img ($(expr \( "${TABLE_SECTORS}" + "${FRMW_SECTORS}" + "${ROOT_SECTORS}" \) \* 512 \/ 1024 \/ 1024)M)" ": successfully created"
851 856
852 857 # Create qemu qcow2 image
853 858 if [ "$ENABLE_QEMU" = true ] ; then
854 859 QEMU_IMAGE=${QEMU_IMAGE:=${BASEDIR}/qemu/${DATE}-${KERNEL_ARCH}-CURRENT-rpi${RPI_MODEL}-${RELEASE}-${RELEASE_ARCH}}
855 860 QEMU_SIZE=16G
856 861
857 862 qemu-img convert -f raw -O qcow2 "$IMAGE_NAME".img "$QEMU_IMAGE".qcow2
858 863 qemu-img resize "$QEMU_IMAGE".qcow2 $QEMU_SIZE
859 864
860 865 echo "$QEMU_IMAGE.qcow2 ($QEMU_SIZE)" ": successfully created"
861 866 fi
862 867 fi
General Comments 0
Vous devez vous connecter pour laisser un commentaire. Se connecter maintenant