source: live-build/trunk/fuentes/scripts/build/lb_binary_rootfs @ 900

Last change on this file since 900 was 900, checked in by kbut, 4 years ago

add original source

  • Property svn:executable set to *
File size: 11.8 KB
Line 
1#!/bin/sh
2
3## live-build(7) - System Build Scripts
4## Copyright (C) 2006-2012 Daniel Baumann <daniel@debian.org>
5##
6## This program comes with ABSOLUTELY NO WARRANTY; for details see COPYING.
7## This is free software, and you are welcome to redistribute it
8## under certain conditions; see COPYING for details.
9
10
11set -e
12
13# Including common functions
14( . "${LIVE_BUILD}/scripts/build.sh" > /dev/null 2>&1 || true ) || . /usr/lib/live/build.sh
15
16# Setting static variables
17DESCRIPTION="$(Echo 'build rootfs image')"
18HELP=""
19USAGE="${PROGRAM} [--force]"
20
21Arguments "${@}"
22
23# Reading configuration files
24Read_conffiles config/all config/common config/bootstrap config/chroot config/binary config/source
25Set_defaults
26
27Echo_message "Begin building root filesystem image..."
28
29# Requiring stage file
30Require_stagefile .build/config .build/bootstrap .build/binary_chroot
31
32# Checking stage file
33Check_stagefile .build/binary_rootfs
34
35# Checking lock file
36Check_lockfile .lock
37
38# Creating lock file
39Create_lockfile .lock
40
41case "${LB_ARCHITECTURES}" in
42        amd64|i386)
43                LINUX="vmlinuz"
44                ;;
45
46        powerpc|ppc64el)
47                LINUX="vmlinux"
48                ;;
49esac
50
51case "${LB_INITRAMFS}" in
52        casper)
53                INITFS="casper"
54                ;;
55
56        live-boot)
57                INITFS="live"
58                ;;
59
60        *)
61                INITFS="boot"
62                ;;
63esac
64
65# Creating directory
66mkdir -p binary/${INITFS}
67
68for STAGE in ${LB_CACHE_STAGES}
69do
70        if [ "${STAGE}" = "rootfs" ] && [ -d cache/binary_rootfs ]
71        then
72                # Removing old chroot
73                rm -rf binary/"${INITFS}"/filesystem.*
74
75                # Restoring old cache
76                mkdir -p binary/"${INITFS}"
77                ${LB_ROOT_COMMAND} cp -a cache/binary_rootfs/filesystem.* binary/"${INITFS}"
78
79                if [ -n "${LB_ROOT_COMMAND}" ]
80                then
81                        ${LB_ROOT_COMMAND} chown -R $(whoami):$(whoami) binary
82                fi
83
84                # Creating stage file
85                Create_stagefile .build/binary_rootfs
86                exit 0
87        fi
88done
89
90case "${LB_CHROOT_FILESYSTEM}" in
91        ext2|ext3|ext4)
92                # Checking depends
93                Check_package chroot/sbin/mkfs.${LB_CHROOT_FILESYSTEM} e2fsprogs
94
95                # Restoring cache
96                Restore_cache cache/packages.binary
97
98                # Installing depends
99                Install_package
100
101                # Remove old image
102                if [ -f binary/${INITFS}/filesystem.${LB_CHROOT_FILESYSTEM} ]
103                then
104                        rm -f binary/${INITFS}/filesystem.${LB_CHROOT_FILESYSTEM}
105                fi
106
107                case "${LB_BUILD_WITH_CHROOT}" in
108                        true)
109                                DU_DIM="$(du -ms chroot/chroot | cut -f1)"
110                                INODES="$(find chroot/chroot | wc -l)"
111                                ;;
112
113                        false)
114                                DU_DIM="$(du -ms chroot | cut -f1)"
115                                INODES="$(find chroot | wc -l)"
116                                ;;
117                esac
118
119                REAL_DIM="$(Calculate_partition_size ${DU_DIM} ${LB_CHROOT_FILESYSTEM})"
120                REAL_INODES="$(Calculate_partition_size ${INODES} ${LB_CHROOT_FILESYSTEM})"
121
122                case "${LB_BUILD_WITH_CHROOT}" in
123                        true)
124                                dd if=/dev/zero of=chroot/filesystem.${LB_CHROOT_FILESYSTEM} bs=1024k count=0 seek=${REAL_DIM}
125
126                                if ! Chroot chroot "test -s /etc/mtab"
127                                then
128                                        Chroot chroot "ln -s /proc/mounts/mtab /etc/mtab"
129                                        FAKE_MTAB="true"
130                                fi
131
132                                Chroot chroot "mkfs.${LB_CHROOT_FILESYSTEM} -F -b ${LB_EXT_BLOCKSIZE:-1024} -i 8192 -m 0 -L ${LB_HDD_LABEL} ${LB_EXT_RESIZEBLOCKS:+-E resize=${LB_EXT_RESIZEBLOCKS}} filesystem.${LB_CHROOT_FILESYSTEM}"
133
134                                mkdir -p filesystem.tmp
135                                ${LB_ROOT_COMMAND} mount -o loop chroot/filesystem.${LB_CHROOT_FILESYSTEM} filesystem.tmp
136                                cp -a chroot/chroot/* filesystem.tmp
137
138                                if [ "${FAKE_MTAB}" = "true" ]
139                                then
140                                        Chroot chroot "rm -f /etc/mtab"
141                                fi
142
143                                ${LB_ROOT_COMMAND} umount filesystem.tmp
144                                rmdir filesystem.tmp
145
146                                # Move image
147                                mv chroot/filesystem.${LB_CHROOT_FILESYSTEM} binary/${INITFS}
148
149                                case "${LB_MODE}" in
150                                        ubuntu|kubuntu)
151                                                du -B 1 -s chroot/chroot | cut -f1 > binary/${INITFS}/filesystem.size
152                                                ;;
153                                esac
154
155                                if [ -e chroot/chroot.cache ]
156                                then
157                                        rm -f .lock
158                                        mv chroot/chroot chroot.tmp
159
160                                        lb chroot_archives binary remove ${*}
161                                        lb chroot_apt remove ${*}
162                                        lb chroot_hostname remove ${*}
163                                        lb chroot_resolv remove ${*}
164                                        lb chroot_hosts remove ${*}
165                                        lb chroot_sysv-rc remove ${*}
166                                        lb chroot_upstart remove ${*}
167                                        lb chroot_dpkg remove ${*}
168                                        lb chroot_debianchroot remove ${*}
169                                        lb chroot_sysfs remove ${*}
170                                        lb chroot_selinuxfs remove ${*}
171                                        lb chroot_proc remove ${*}
172                                        lb chroot_devpts remove ${*}
173
174                                        rm -rf chroot
175                                        mv chroot.tmp chroot
176
177                                        lb chroot_devpts install ${*}
178                                        lb chroot_proc install ${*}
179                                        lb chroot_selinuxfs install ${*}
180                                        lb chroot_sysfs install ${*}
181                                        lb chroot_debianchroot install ${*}
182                                        lb chroot_dpkg install ${*}
183                                        lb chroot_sysv-rc install ${*}
184                                        lb chroot_upstart install ${*}
185                                        lb chroot_hosts install ${*}
186                                        lb chroot_resolv install ${*}
187                                        lb chroot_hostname install ${*}
188                                        lb chroot_apt install ${*}
189                                        lb chroot_archives binary install ${*}
190
191                                        touch .lock
192                                else
193                                        rm -rf chroot/chroot
194
195                                        # Removing depends
196                                        Remove_package
197                                fi
198                                ;;
199
200                        false)
201                                dd if=/dev/zero of=binary/${INITFS}/filesystem.${LB_CHROOT_FILESYSTEM} bs=1024k count=0 seek=${REAL_DIM}
202                                mkfs.${LB_CHROOT_FILESYSTEM} -F -b ${LB_EXT_BLOCKSIZE:-1024} -i 8192 -m 0 -L ${LB_HDD_LABEL} ${LB_EXT_RESIZEBLOCKS:+-E resize=${LB_EXT_RESIZEBLOCKS}} binary/${INITFS}/filesystem.${LB_CHROOT_FILESYSTEM}
203
204                                mkdir -p filesystem.tmp
205                                ${LB_ROOT_COMMAND} mount -o loop binary/${INITFS}/filesystem.${LB_CHROOT_FILESYSTEM} filesystem.tmp
206                                cp -a chroot/* filesystem.tmp
207
208                                ${LB_ROOT_COMMAND} umount filesystem.tmp
209                                rmdir filesystem.tmp
210                                ;;
211                esac
212
213                # Saving cache
214                Save_cache cache/packages.binary
215                ;;
216
217        jffs2)
218                # Checking depends
219                Check_package chroot/usr/sbin/mkfs.jffs2 mtd-tools
220
221                # Restoring cache
222                Restore_cache cache/packages.binary
223
224                # Installing depends
225                Install_package
226
227                # Remove old jffs2 image
228                if [ -f binary/${INITFS}/filesystem.jffs2 ]
229                then
230                        rm -f binary/${INITFS}/filesystem.jffs2
231                fi
232
233                if [ -n "${LB_JFFS2_ERASEBLOCK}" ]
234                then
235                        JFFS2_OPTIONS="--eraseblock=${LB_JFFS2_ERASEBLOCK}"
236                fi
237
238                case "${LB_BUILD_WITH_CHROOT}" in
239                        true)
240                                Chroot chroot "mkfs.jffs2 ${JFFS2_OPTIONS} --root=chroot --output filesystem.jffs2"
241
242                                # Move image
243                                mv chroot/filesystem.jffs2 binary/${INITFS}
244
245                                if [ -e chroot/chroot.cache ]
246                                then
247                                        rm -f .lock
248                                        mv chroot/chroot chroot.tmp
249
250                                        lb chroot_archives binary remove ${*}
251                                        lb chroot_apt remove ${*}
252                                        lb chroot_hostname remove ${*}
253                                        lb chroot_resolv remove ${*}
254                                        lb chroot_hosts remove ${*}
255                                        lb chroot_sysv-rc remove ${*}
256                                        lb chroot_upstart remove ${*}
257                                        lb chroot_dpkg remove ${*}
258                                        lb chroot_debianchroot remove ${*}
259                                        lb chroot_sysfs remove ${*}
260                                        lb chroot_selinuxfs remove ${*}
261                                        lb chroot_proc remove ${*}
262                                        lb chroot_devpts remove ${*}
263
264                                        rm -rf chroot
265                                        mv chroot.tmp chroot
266
267                                        lb chroot_devpts install ${*}
268                                        lb chroot_proc install ${*}
269                                        lb chroot_selinuxfs install ${*}
270                                        lb chroot_sysfs install ${*}
271                                        lb chroot_debianchroot install ${*}
272                                        lb chroot_dpkg install ${*}
273                                        lb chroot_sysv-rc install ${*}
274                                        lb chroot_upstart install ${*}
275                                        lb chroot_hosts install ${*}
276                                        lb chroot_resolv install ${*}
277                                        lb chroot_hostname install ${*}
278                                        lb chroot_apt install ${*}
279                                        lb chroot_archives binary install ${*}
280
281                                        touch .lock
282                                else
283                                        rm -rf chroot/chroot
284
285                                        # Removing depends
286                                        Remove_package
287                                fi
288                                ;;
289
290                        false)
291                                mkfs.jffs2 ${JFFS2_OPTIONS} --root=chroot --output binary/${INITFS}/filesystem.jffs2
292                                ;;
293                esac
294
295                # Saving cache
296                Save_cache cache/packages.binary
297                ;;
298
299        plain)
300                if [ -d binary/${INITFS}/filesystem.dir ]
301                then
302                        rm -rf binary/${INITFS}/filesystem.dir
303                fi
304
305                case "${LB_BUILD_WITH_CHROOT}" in
306                        true)
307                                mv chroot/chroot binary/${INITFS}/filesystem.dir
308                                ;;
309
310                        false)
311                                cp -a chroot binary/${INITFS}/filesystem.dir
312                                ;;
313                esac
314                ;;
315
316        squashfs)
317                # Checking depends
318                Check_package chroot/usr/share/doc/squashfs-tools squashfs-tools
319
320                # Restoring cache
321                Restore_cache cache/packages.binary
322
323                # Installing depends
324                Install_package
325
326                Echo_message "Preparing squashfs image..."
327                Echo_message "This may take a while."
328
329                # Remove old squashfs image
330                if [ -f binary/${INITFS}/filesystem.squashfs ]
331                then
332                        rm -f binary/${INITFS}/filesystem.squashfs
333                fi
334
335                # Remove stale squashfs image
336                rm -f chroot/filesystem.squashfs
337
338                MKSQUASHFS_OPTIONS="${MKSQUASHFS_OPTIONS} -no-progress"
339
340                if [ "${_VERBOSE}" = "true" ]
341                then
342                        MKSQUASHFS_OPTIONS="${MKSQUASHFS_OPTIONS} -info"
343                fi
344
345                if [ -f config/binary_rootfs/squashfs.sort ]
346                then
347                        MKSQUASHFS_OPTIONS="${MKSQUASHFS_OPTIONS} -sort squashfs.sort"
348
349                        case "${LB_BUILD_WITH_CHROOT}" in
350                                true)
351                                        cp config/binary_rootfs/squashfs.sort chroot
352                                        ;;
353
354                                false)
355                                        cp config/binary_rootfs/squashfs.sort .
356                                        ;;
357                        esac
358                fi
359
360                case "${LB_PARENT_DISTRIBUTION}" in
361                        squeeze)
362
363                                ;;
364
365                        *)
366                                case "${LB_MODE}" in
367                                        ubuntu|kubuntu)
368
369                                                ;;
370                                        *)
371                                                # FIXME: artax-backports too, once d-i has catched up
372                                                MKSQUASHFS_OPTIONS="${MKSQUASHFS_OPTIONS} -comp xz"
373                                                ;;
374                                esac
375                                ;;
376                esac
377
378                case "${LB_BUILD_WITH_CHROOT}" in
379                        true)
380                                if [ -e config/binary_rootfs/excludes ]
381                                then
382                                        cp config/binary_rootfs/excludes chroot/excludes
383
384                                        MKSQUASHFS_OPTIONS="${MKSQUASHFS_OPTIONS} -wildcards -ef /excludes"
385                                fi
386
387                                # Create image
388                                Chroot chroot "mksquashfs chroot filesystem.squashfs ${MKSQUASHFS_OPTIONS}"
389
390                                rm -f chroot/chroot/excludes
391
392                                case "${LB_MODE}" in
393                                        ubuntu|kubuntu)
394                                                du -B 1 -s chroot/chroot | cut -f1 > binary/${INITFS}/filesystem.size
395                                                ;;
396                                esac
397
398                                # Move image
399                                ${LB_ROOT_COMMAND} mv chroot/filesystem.squashfs binary/${INITFS}
400                                ${LB_ROOT_COMMAND} rm -f chroot/squashfs.sort
401
402                                if [ -e chroot/chroot.cache ]
403                                then
404                                        rm -f .lock
405                                        mv chroot/chroot chroot.tmp
406
407                                        lb chroot_archives binary remove ${*}
408                                        lb chroot_apt remove ${*}
409                                        lb chroot_hostname remove ${*}
410                                        lb chroot_resolv remove ${*}
411                                        lb chroot_hosts remove ${*}
412                                        lb chroot_sysv-rc remove ${*}
413                                        lb chroot_upstart remove ${*}
414                                        lb chroot_dpkg remove ${*}
415                                        lb chroot_debianchroot remove ${*}
416                                        lb chroot_sysfs remove ${*}
417                                        lb chroot_selinuxfs remove ${*}
418                                        lb chroot_proc remove ${*}
419                                        lb chroot_devpts remove ${*}
420
421                                        rm -rf chroot
422                                        mv chroot.tmp chroot
423
424                                        lb chroot_devpts install ${*}
425                                        lb chroot_proc install ${*}
426                                        lb chroot_selinuxfs install ${*}
427                                        lb chroot_sysfs install ${*}
428                                        lb chroot_debianchroot install ${*}
429                                        lb chroot_dpkg install ${*}
430                                        lb chroot_sysv-rc install ${*}
431                                        lb chroot_upstart install ${*}
432                                        lb chroot_hosts install ${*}
433                                        lb chroot_resolv install ${*}
434                                        lb chroot_hostname install ${*}
435                                        lb chroot_apt install ${*}
436                                        lb chroot_archives binary install ${*}
437
438                                        touch .lock
439                                else
440                                        rm -rf chroot/chroot
441
442                                        # Removing depends
443                                        Remove_package
444                                fi
445
446                                ${LB_ROOT_COMMAND} chmod 0644 binary/${INITFS}/filesystem.squashfs
447                                ;;
448
449                        false)
450                                if [ -e config/binary_rootfs/excludes ]
451                                then
452                                        MKSQUASHFS_OPTIONS="${MKSQUASHFS_OPTIONS} -wildcards -ef config/binary_rootfs/excludes"
453                                fi
454
455                                mksquashfs chroot binary/${INITFS}/filesystem.squashfs ${MKSQUASHFS_OPTIONS}
456
457                                case "${LB_MODE}" in
458                                        ubuntu|kubuntu)
459                                                du -B 1 -s chroot | cut -f1 > binary/${INITFS}/filesystem.size
460                                                ;;
461                                esac
462                                ;;
463                esac
464
465                if [ -n "${LB_ROOT_COMMAND}" ]
466                then
467                        ${LB_ROOT_COMMAND} chown -R $(whoami):$(whoami) binary/${INITFS}
468                fi
469
470                # Saving cache
471                Save_cache cache/packages.binary
472                ;;
473
474        none)
475                if [ -d binary ]
476                then
477                        rm -rf binary
478                fi
479
480                case "${LB_BUILD_WITH_CHROOT}" in
481                        true)
482                                mv chroot/chroot binary
483                                ;;
484
485                        false)
486                                Echo_message "This may take a while."
487                                cp -a chroot binary
488                                ;;
489                esac
490                ;;
491
492esac
493
494for STAGE in ${LB_CACHE_STAGES}
495do
496        if [ "${STAGE}" = "rootfs" ]
497        then
498                rm -rf cache/binary_rootfs
499
500                mkdir -p cache/binary_rootfs
501
502                if [ "${LB_CHROOT_FILESYSTEM}" != "none" ]
503                then
504                        ${LB_ROOT_COMMAND} cp -a binary/"${INITFS}"/filesystem.* cache/binary_rootfs
505                fi
506
507                if [ -n "${LB_ROOT_COMMAND}" ]
508                then
509                        ${LB_ROOT_COMMAND} chown -R $(whoami):$(whoami) cache/binary_rootfs
510                fi
511        fi
512done
513
514# Creating stage file
515Create_stagefile .build/binary_rootfs
Note: See TracBrowser for help on using the repository browser.