summaryrefslogtreecommitdiff
path: root/util/mkblankimage.sh
blob: 43a3cca29347845a3cfaf4bf995de077a46092b4 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
#!/bin/sh
#
# makeblankimage.sh
# Make a blank M5 disk image
#

while getopts "m" OPT
do
        case "$OPT" in
                m)  MOUNT_IT=1
        esac
done

DEBUG=0

if [ $DEBUG -ne 0 ]; then
    set -x -e
    OUTPUT=""
else
    OUTPUT="> /dev/null 2>&1"
fi

abort() {
    echo $@
    exec /bin/false
}

find_prog() {
    PROG_PATH=`which $1`
    if [ $? -ne 0 ]; then
        abort "Unable to find program $1, check your PATH variable"
    fi
    echo $PROG_PATH
}

run_priv() {
    if [ "$HAVE_SUDO" = "y" ]; then
        eval $SUDO $@ $OUTPUT
    else
        eval $@ $OUTPUT
    fi

    if [ $? -ne 0 ]; then
        abort "Failed to run $@ as root"
    fi
}

usage() {
    abort "Usage: $0 [root-path to copy] [extra ownership commands ...]"
}

# Setup PATH to look in the sbins
export PATH=$PATH:/sbin:/usr/sbin

# Get all of the programs needed, or exit
DD=`find_prog dd`
SFDISK=`find_prog sfdisk`
LOSETUP=`find_prog losetup`
SUDO=`find_prog sudo`
MKE2FS=`find_prog mke2fs`
MKDIR=`find_prog mkdir`
MOUNT=`find_prog mount`
UMOUNT=`find_prog umount`
WHOAMI=`find_prog whoami`
CP=`find_prog cp`
CHOWN=`find_prog chown`

# Prompt for the root password, if needed
CUR_USER=`$WHOAMI`

if [ $# -ge 1 ]; then
    if [ ! $MOUNT_IT ]; then
        ROOT_PATH=$1

        if [ ! -d $ROOT_PATH ]; then
                usage
        fi
   else
        ROOT_PATH=""
   fi
else
    ROOT_PATH=""
fi

if [ ! "$CUR_USER" = "root" ]; then
    echo -n "Do you have sudo access? [y/n] "
    read HAVE_SUDO

    if [ ! "$HAVE_SUDO" = "y" ]; then
        abort "You must have sudo access or run this script as root"
    fi
fi

echo -n "How large do you want this disk image (in MB): "
read USER_SIZE_MB

# size in bytes = SIZE_MB * 1024 * 1024
# size in blocks = SIZE_BYTE / 512
let BLK_SIZE=$USER_SIZE_MB*1024*2

let MAX_LBA=16383*16*63

if [ $BLK_SIZE -ge $MAX_LBA ]; then
    CYLS=16383
    HEADS=16
    SECTORS=63
else
    # Set Sectors
    if [ $BLK_SIZE -ge 63 ]; then
        SECTORS=63
    else
        SECTORS=$BLK_SIZE
    fi

    # Set Heads
    let HEAD_SIZE=$BLK_SIZE/$SECTORS

    if [ $HEAD_SIZE -ge 16 ]; then
        HEADS=16
    else
        HEADS=$BLK_SIZE
    fi

    # Set Cylinders
    let SEC_HEAD=$SECTORS*$HEADS
    let CYLS=$BLK_SIZE/$SEC_HEAD
fi

# Recalculate number of sectors
let BLK_SIZE=$CYLS*$HEADS*$SECTORS

# Get the name of the file and directory to build in
echo -n "What directory would you like to build the image in? "
read IMAGE_DIR

if [ ! -d $IMAGE_DIR ]; then
    abort "The directory $IMAGE_DIR does not exist"
fi

echo -n "What would you like to name the image? "
read IMAGE_NAME

IMAGE_FILE=$IMAGE_DIR/$IMAGE_NAME

# DD the blank image
echo
echo "dd'ing the blank image (this make take a while)..."
eval $DD if=/dev/zero of=$IMAGE_FILE bs=512 count=$BLK_SIZE $OUTPUT
if [ $? -ne 0 ]; then
    abort "Unable to create the blank image $IMAGE_NAME in $IMAGE_DIR"
fi

# losetup the image with no offset to do the fdisk
echo
echo "Binding the image and partitioning..."
run_priv $LOSETUP /dev/loop0 $IMAGE_FILE
if [ $? -ne 0 ]; then
    abort "losetup to /dev/loop0 failed, make sure nothing is setup on loop0 (check by typing 'mount') "
fi

# fdisk the image
run_priv $SFDISK --no-reread -D -C $CYLS -H $HEADS -S $SECTORS /dev/loop0 <<EOF
0,
;
;
;
EOF

# Un-losetup the image
run_priv $LOSETUP -d /dev/loop0

# Mount the image with an offset and make the filesystem
echo
echo "Remounting image and formatting..."
let BASE_OFFSET=63*512

run_priv $LOSETUP -o $BASE_OFFSET /dev/loop0 $IMAGE_FILE

run_priv $MKE2FS /dev/loop0

# If a root path was specified then copy the root path into the image
if [ ! -z "$ROOT_PATH" ]; then
    echo "Copying root from $ROOT_PATH to image file"

    run_priv $MKDIR -p /tmp/mnt

    run_priv $MOUNT /dev/loop0 /tmp/mnt

    run_priv $CP -a $ROOT_PATH/* /tmp/mnt

    run_priv $CHOWN -R root.root /tmp/mnt

    # run extra permissions while disk is mounted
    TOPDIR=`pwd`
    cd /tmp/mnt
    i=2
    while [ $i -le $# ]; do
        run_priv ${!i}
        let i=i+1
    done
    cd $TOPDIR

    run_priv $UMOUNT /tmp/mnt
fi

run_priv $LOSETUP -d /dev/loop0


if [ $MOUNT_IT -eq 1 ]; then
        run_priv mount -o loop,offset=$BASE_OFFSET $IMAGE_FILE /tmp/mnt
else
        echo
        echo "Disk image creation complete."
        echo "To mount the image, run the following commands:"
        echo "# $MOUNT -o loop,offset=$BASE_OFFSET $IMAGE_FILE /mount/point"
        echo
        echo "And to unmount the image, run:"
        echo "# $UMOUNT /mount/point"
fi;