mkarchiso 10.2 KB
Newer Older
1
#! /bin/bash
2
3
4
5

PKGLIST=""
QUIET="y"
FORCE="n"
6
PACCONFIG="/etc/pacman.conf"
7
8
9
10
export LABEL="ARCHISO_$(pwgen -n 8 1 | tr [a-z] [A-Z])"
PUBLISHER="Arch Linux <http://www.archlinux.org>"
APPLICATION="Arch Linux Live/Rescue CD"
CREATE_DEFAULT="n"
11
12
13
14
15
16
17
18
19

APPNAME=$(basename "${0}")

# usage: usage <exitvalue>
usage ()
{
    echo "usage ${APPNAME} [options] command <command options>"
    echo " general options:"
    echo "    -f               Force overwrite of working files/squashfs image/bootable image"
20
    echo "    -p PACKAGE(S)    Additional package(s) to install, can be used multiple times"
21
    echo "    -C <file>        Config file for pacman. Default $PACCONFIG"
22
23
24
25
26
27
    echo "    -L <label>       Set a label for the disk"
    echo "    -P <publisher>   Set a publisher for the disk"
    echo "    -A <application> Set an application name for the disk"
    echo "    -d               Create default user directory /home/arch"
    echo "    -v               Enable verbose output"
    echo "    -h               This message"
28
    echo " commands:"
29
30
31
32
33
34
35
    echo "   create <dir>"
    echo "      create a base directory layout to work with"
    echo "      includes all specified packages"
    echo "   iso -p <bootloader> <dir> <image name>"
    echo "      build an iso image from the working dir"
    echo "   usb -p <bootloader> <dir> <image name>"
    echo "      build an iso image from the working dir"
36
37
38
    exit $1
}

39
while getopts 'p:C:L:P:A:dfvh' arg; do
40
41
    case "${arg}" in
        p) PKGLIST="${PKGLIST} ${OPTARG}" ;;
42
        C) PACCONFIG="${OPTARG}" ;;
43
44
45
46
    	L) LABEL="${OPTARG}" ;;
    	P) PUBLISHER="${OPTARG}" ;;
    	A) APPLICATION="${OPTARG}" ;;
        d) CREATE_DEFAULT="y" ;;
47
48
49
50
51
52
53
        f) FORCE="y" ;;
        v) QUIET="n" ;;
        h|?) usage 0 ;;
        *) echo "invalid argument '${arg}'"; usage 1 ;;
    esac
done

54
55
56
#trim spaces
PKGLIST="$(echo $PKGLIST)"

57
58
59
60
61
62
63
64
shift $(($OPTIND - 1))

# do UID checking here so someone can at least get usage instructions
if [ "$EUID" != "0" ]; then
    echo "error: This script must be run as root."
    exit 1
fi

65
66
67
68
69
if [ ! -f "$PACCONFIG" ]; then
    echo "error: pacman config file '$PACCONFIG' does not exist"
    exit 1
fi

70
command_name="${1}"
71
72
73
work_dir=""
imgname=""

74
case "${command_name}" in
75
76
77
    create) work_dir="${2}"; imgname="none" ;;
    iso) work_dir="${2}"; imgname="${3}" ;;
    usb) work_dir="${2}"; imgname="${3}" ;;
78
79
80
    *) echo "invalid command name '${command_name}'"; usage 1 ;;
esac

81
82
[ "x${imgname}" = "x" ] && echo "Image name must be specified" && usage 1
[ "x${work_dir}" = "x" ] && echo "Please specify a working directory" && usage 1
83

84
85
86
87
echo "${APPNAME} : Configuration Settings"
echo "        working directory:   ${work_dir}"
echo "               image name:   ${imgname}"

88
89
90
91
92
# usage: _pacman <packages>...
_pacman ()
{
    local ret
    if [ "${QUIET}" = "y" ]; then
93
        mkarchroot -C "$PACCONFIG" -f "${work_dir}/root-image" $* 2>&1 >/dev/null
94
95
        ret=$?
    else
96
        mkarchroot -C "$PACCONFIG" -f "${work_dir}/root-image" $*
97
98
        ret=$?
    fi
99
100
101
102

    # Cleanup
    find "${work_dir}" -name *.pacnew -name *.pacsave -name *.pacorig -delete

103
104
105
106
107
    if [ $ret -ne 0 ]; then
        exit 1
    fi
}

108
109
110
111
112
113
114
115
116
command_create () {
    echo "====> Creating working directory: ${work_dir}"
    mkdir -p "${work_dir}/iso/"
    mkdir -p "${work_dir}/root-image/"
    echo "# archiso isomounts file
# img - location of image/directory to mount relative to addons directory
# arch - architecture of this image
# mount point - absolute location on the post-initrd root
# type - either 'bind' or 'squashfs' for now
117

118
# syntax: <img> <arch> <mount point> <type>
119

120
121
122
# NOTE: Order matters. If the same file exists in multiple
#  images, the FIRST one mounted, top-down, will take precedence

123
124
root-image.sqfs i686 / squashfs
#root-image-x86_64.sqfs x86_64 / squashfs" > "${work_dir}/isomounts"
125

126
    echo "README for this archiso created directory
127

128
129
130
All directories in this dir, except for 'iso' will be squashed
with squashfs and put into the iso dir as iso/<dirname>.sqfs
This should be reflected in the isomounts file
131

132
The iso dir is later used to build the actual bootable iso.
133
134
Please ensure the proper bootloader is installed or copied
to the iso/ directory.
135
136

...TODO: Write more..." > "${work_dir}/README"
137

138
139
140
    if [ "${PKGLIST}" != "" ]; then
        echo "====> Installing packages to '${work_dir}/root-image/'"
        _pacman "${PKGLIST}"
141

142
143
144
        echo "Cleaning up what we can"
        if [ -d "${work_dir}/root-image/boot/" ]; then
            # remove the initcpio images that were generated for the host system
145
            find "${work_dir}/root-image/boot" -name '*.img' -delete
146
147
        fi

148
        #TODO is this needed? do it at the Makefile level?
149
150
151
152
153
        if [ ${CREATE_DEFAULT} == "y" ]; then
            if [ -d "${work_dir}/root-image/home/" ]; then
                echo "Creating default home directory"
                install -d -o1000 -g100 -m0755 "${work_dir}/root-image/home/arch"
            fi
154
155
156
157
158
159
160
161
162
163
        fi

        # delete a lot of unnecessary cache/log files
        kill_dirs="var/abs var/cache/man var/cache/pacman var/lib/pacman/sync var/log/* var/mail tmp/* initrd"
        for x in ${kill_dirs}; do
            if [ -e "${work_dir}/root-image/${x}" ]; then
                rm -rf "${work_dir}/root-image/${x}"
            fi
        done
    fi
164
}
165

166
167
168
169
170
171
172
173
174
175
# _mksquash dirname
_mksquash () {
    if [ ! -d "$1" ]; then
        echo "Error: '$1' is not a directory"
        return 1
    fi

    sqimg="${work_dir}/iso/$(basename ${1}).sqfs"
    echo "====> Generating SquashFS image for '${1}'"
    if [ -e "${sqimg}" ]; then
176
177
178
        dirhaschanged=$(find ${1} -newer ${sqimg})
        if [ "${dirhaschanged}" != "" ]; then
            echo "SquashFS image '${sqimg}' is not up to date, rebuilding..."
179
            rm "${sqimg}"
180
        else
181
182
            echo "SquashFS image '${sqimg}' is up to date, skipping."
            return
183
184
185
        fi
    fi

186
    echo "Creating SquashFS image. This may take some time..."
187
188
    start=$(date +%s)
    if [ "${QUIET}" = "y" ]; then
189
        mksquashfs "${1}" "${sqimg}" -noappend >/dev/null
190
    else
191
        mksquashfs "${1}" "${sqimg}" -noappend
192
193
194
    fi
    minutes=$(echo $start $(date +%s) | awk '{ printf "%0.2f",($2-$1)/60 }')
    echo "Image creation done in $minutes minutes."
195
}
196

197
198
199
200
201
202
203
204
205
_imgcommon () {
    for d in $(find "${work_dir}" -maxdepth 1 -type d -name '[^.]*'); do
        if [ "$d" != "${work_dir}/iso" -a \
             "$(basename "$d")" != "iso" -a \
             "$d" != "${work_dir}" ]; then
            _mksquash "$d"
        fi
    done

206
    echo "====> Making bootable image"
207
208
209
210
211
212
213
214
215
216
217
218
219

    # Sanity checks
    if [ ! -d "${work_dir}/iso" ]; then
        echo "Error: '${work_dir}/iso' doesn't exist. What did you do?!"
        exit 1
    fi

    if [ ! -f "${work_dir}/isomounts" ]; then
        echo "Error: the isomounts file doesn't exist. This image won't do anything"
        echo "  Protecting you from yourself and erroring out here..."
        exit 1
    fi

220
221
222
223
224
225
226
227
228
229
    if [ -e "${imgname}" ]; then
        if [ "${FORCE}" = "y" ]; then
            echo "Removing existing bootable image..."
            rm -rf "${imgname}"
        else
            echo "error: Image '${imgname}' already exists, aborting."
            exit 1
        fi
    fi

230
    cp "${work_dir}/isomounts" "${work_dir}/iso/"
231
232
233

    [ -f ${work_dir}/iso/boot/grub/menu.lst ] && sed "s|archisolabel=[^ ]*|archisolabel=${LABEL}|" -i ${work_dir}/iso/boot/grub/menu.lst
    [ -f ${work_dir}/iso/boot/isolinux/isolinux.cfg ] && sed "s|archisolabel=[^ ]*|archisolabel=${LABEL}|" -i ${work_dir}/iso/boot/isolinux/isolinux.cfg
234
235
236
237
}

command_iso () {
    _imgcommon
Aaron Griffin's avatar
Aaron Griffin committed
238

239
    bootflags=""
240
    if [ "$PKGLIST" = "grub" -o "$PKGLIST" = "grub-gfx" ]; then
241
242
        if [ ! -e "${work_dir}/iso/boot/grub/stage2_eltorito" ]; then
            echo "error: grub stage files not found in '${work_dir}/iso/boot/grub'"
243
244
            exit 1
        fi
Aaron Griffin's avatar
Aaron Griffin committed
245
246

        bootflags="-b boot/grub/stage2_eltorito"
247
    elif [ "$PKGLIST" = "syslinux" ]; then
248
249
        if [ ! -e "${work_dir}/iso/boot/isolinux/isolinux.bin" ]; then
            echo "error: isolinux bin file not found in '${work_dir}/iso/boot/isolinux'"
250
251
            exit 1
        fi
Aaron Griffin's avatar
Aaron Griffin committed
252
253

        bootflags="-b boot/isolinux/isolinux.bin -c boot/isolinux/boot.cat"
254
    else
Aaron Griffin's avatar
Aaron Griffin committed
255
256
257
        echo "No bootloader specified. Use the -p flag to specify"
        echo "  Supported Bootloaders:"
        echo "     grub"
258
        echo "     grub-gfx"
259
        echo "     syslinux"
Aaron Griffin's avatar
Aaron Griffin committed
260
        exit 1
261
    fi
262

263
264
    echo "Creating ISO image..."
    qflag=""
Gerhard Brauer's avatar
Gerhard Brauer committed
265
    [ "${QUIET}" = "y" ] && qflag="-quiet"
266
    mkisofs ${qflag} -r -l $bootflags -uid 0 -gid 0 \
267
    	-udf -allow-limited-size -iso-level 3 \
268
269
        -input-charset utf-8 -p "prepared by mkarchiso" \
        -no-emul-boot -boot-load-size 4 -boot-info-table \
270
271
        -publisher "${PUBLISHER}" \
        -A "${APPLICATION}" \
272
        -V "${LABEL}" \
273
274
275
276
277
        -o "${imgname}" "${work_dir}/iso/"
}

command_usb () {
    _imgcommon
278

279
    modprobe -q loop > /dev/null 2>&1
280
281
282
283
284
285

    # Calculate cylinder size in bytes
    CYL_SIZE=$((255*63*512))

    # First partition offset
    PART_OFFSET=$((63*512))
286
287

    # ext2 overhead's upper bound is 6%, empirically tested up to 1GB
Aaron Griffin's avatar
Aaron Griffin committed
288
    rootsize=$(du -bs "${work_dir}/iso" | cut -f1)
289
290
291
292
    imgsz=$(( (${rootsize}*106)/100/${CYL_SIZE} + 1 )) # image size in cylinders

    # Get next free loop device
    devloop=$(losetup -f)
293
294

    # create the filesystem image file
295
296
297
298
    dd if=/dev/zero of="$imgname" bs="$CYL_SIZE" count="$imgsz"

    # Setup a loop device, and skip the first 63 sectors
    losetup "$devloop" -o "$PART_OFFSET" "$imgname"
299
300

    # create a filesystem on the image
301
    mke2fs -m 0 -F -L "${LABEL}" "$devloop"
302
303
304

    # mount the filesystem and copy data
    TMPDIR=$(mktemp -d archiso-usbXXXXXX)
305
    mount "$devloop" "$TMPDIR"
306
    cp -a "${work_dir}"/iso/* "$TMPDIR"
307
    umount -d "$TMPDIR"
308
    rm -rf "$TMPDIR"
309
310

    # create a partition table
311
312
313
314
315
316
317
318
319
320
    fdisk -C "$imgsz" -H 255 -S 63 "$imgname" << EOF
n
p
1


a
1
p
w
321
322
323
324
EOF

    # install grub on the image
    grub --no-floppy --batch << EOF
325
326
327
device (hd0) ${imgname}
root (hd0,0)
setup (hd0)
328
329
330
331
EOF

}

332
333
# Go through the main commands in order. If 'all' was specified, then we want
# to do everything. Start with 'install'.
334
335
if [ "${command_name}" = "create"  ]; then
    command_create
336
fi
337
338
if [ "${command_name}" = "iso" ]; then
    command_iso
339
fi
340
341
if [ "${command_name}" = "usb" ]; then
    command_usb
342
343
344
fi

# vim:ts=4:sw=4:et: