]>
Commit | Line | Data |
---|---|---|
75153387 | 1 | #!/bin/bash |
f29e7ac5 | 2 | # |
a9382908 | 3 | # Copyright (C) 2007-2012 Red Hat, Inc. All rights reserved. |
f29e7ac5 AK |
4 | # |
5 | # This file is part of LVM2. | |
6 | # | |
7 | # This copyrighted material is made available to anyone wishing to use, | |
8 | # modify, copy, or redistribute it subject to the terms and conditions | |
9 | # of the GNU General Public License v.2. | |
10 | # | |
11 | # You should have received a copy of the GNU General Public License | |
12 | # along with this program; if not, write to the Free Software Foundation, | |
13 | # Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
14 | # | |
50c41b09 | 15 | # Author: Zdenek Kabelac <zkabelac at redhat.com> |
f29e7ac5 AK |
16 | # |
17 | # Script for resizing devices (usable for LVM resize) | |
18 | # | |
19 | # Needed utilities: | |
20 | # mount, umount, grep, readlink, blockdev, blkid, fsck, xfs_check | |
21 | # | |
cd96532e | 22 | # ext2/ext3/ext4: resize2fs, tune2fs |
f29e7ac5 AK |
23 | # reiserfs: resize_reiserfs, reiserfstune |
24 | # xfs: xfs_growfs, xfs_info | |
25 | # | |
4886fa21 ZK |
26 | # Return values: |
27 | # 0 success | |
28 | # 1 error | |
29 | # 2 break detected | |
30 | # 3 unsupported online filesystem check for given mounted fs | |
f29e7ac5 AK |
31 | |
32 | TOOL=fsadm | |
33 | ||
53c09bce | 34 | _SAVEPATH=$PATH |
f29e7ac5 AK |
35 | PATH=/sbin:/usr/sbin:/bin:/usr/sbin:$PATH |
36 | ||
37 | # utilities | |
38 | TUNE_EXT=tune2fs | |
39 | RESIZE_EXT=resize2fs | |
40 | TUNE_REISER=reiserfstune | |
41 | RESIZE_REISER=resize_reiserfs | |
42 | TUNE_XFS=xfs_info | |
43 | RESIZE_XFS=xfs_growfs | |
44 | ||
45 | MOUNT=mount | |
46 | UMOUNT=umount | |
47 | MKDIR=mkdir | |
50c41b09 ZK |
48 | RMDIR=rmdir |
49 | BLOCKDEV=blockdev | |
50 | BLKID=blkid | |
f0fffb8c | 51 | DATE=date |
f29e7ac5 AK |
52 | GREP=grep |
53 | READLINK=readlink | |
9ad2ba2a | 54 | READLINK_E="-e" |
f29e7ac5 AK |
55 | FSCK=fsck |
56 | XFS_CHECK=xfs_check | |
57 | ||
33048414 | 58 | # user may override lvm location by setting LVM_BINARY |
0d9ed7ad | 59 | LVM=${LVM_BINARY:-lvm} |
17dd04ca | 60 | |
685940c0 | 61 | YES=${_FSADM_YES} |
f29e7ac5 | 62 | DRY=0 |
17dd04ca | 63 | VERB= |
f29e7ac5 | 64 | FORCE= |
a9382908 | 65 | EXTOFF=${_FSADM_EXTOFF:-0} |
17dd04ca | 66 | DO_LVRESIZE=0 |
f29e7ac5 AK |
67 | FSTYPE=unknown |
68 | VOLUME=unknown | |
69 | TEMPDIR="${TMPDIR:-/tmp}/${TOOL}_${RANDOM}$$/m" | |
8f8c5580 | 70 | DM_DEV_DIR="${DM_DEV_DIR:-/dev}" |
f29e7ac5 AK |
71 | BLOCKSIZE= |
72 | BLOCKCOUNT= | |
73 | MOUNTPOINT= | |
74 | MOUNTED= | |
75 | REMOUNT= | |
55b94bf3 | 76 | PROCMOUNTS="/proc/mounts" |
8f8c5580 | 77 | NULL="$DM_DEV_DIR/null" |
f29e7ac5 AK |
78 | |
79 | IFS_OLD=$IFS | |
33048414 ZK |
80 | # without bash $'\n' |
81 | NL=' | |
82 | ' | |
f29e7ac5 AK |
83 | |
84 | tool_usage() { | |
d7b5bfc2 AK |
85 | echo "${TOOL}: Utility to resize or check the filesystem on a device" |
86 | echo | |
87 | echo " ${TOOL} [options] check device" | |
88 | echo " - Check the filesystem on device using fsck" | |
89 | echo | |
50c41b09 | 90 | echo " ${TOOL} [options] resize device [new_size[BKMGTPE]]" |
d7b5bfc2 AK |
91 | echo " - Change the size of the filesystem on device to new_size" |
92 | echo | |
93 | echo " Options:" | |
94 | echo " -h | --help Show this help message" | |
95 | echo " -v | --verbose Be verbose" | |
cd96532e | 96 | echo " -e | --ext-offline unmount filesystem before ext2/ext3/ext4 resize" |
d7b5bfc2 AK |
97 | echo " -f | --force Bypass sanity checks" |
98 | echo " -n | --dry-run Print commands without running them" | |
17dd04ca | 99 | echo " -l | --lvresize Resize given device (if it is LVM device)" |
d7b5bfc2 AK |
100 | echo " -y | --yes Answer \"yes\" at any prompts" |
101 | echo | |
102 | echo " new_size - Absolute number of filesystem blocks to be in the filesystem," | |
103 | echo " or an absolute size using a suffix (in powers of 1024)." | |
104 | echo " If new_size is not supplied, the whole device is used." | |
105 | ||
f29e7ac5 AK |
106 | exit |
107 | } | |
108 | ||
109 | verbose() { | |
17dd04ca | 110 | test -n "$VERB" && echo "$TOOL: $@" || true |
f29e7ac5 AK |
111 | } |
112 | ||
113 | error() { | |
114 | echo "$TOOL: $@" >&2 | |
115 | cleanup 1 | |
116 | } | |
117 | ||
118 | dry() { | |
50c41b09 ZK |
119 | if [ "$DRY" -ne 0 ]; then |
120 | verbose "Dry execution $@" | |
121 | return 0 | |
122 | fi | |
f29e7ac5 | 123 | verbose "Executing $@" |
a9382908 | 124 | "$@" |
f29e7ac5 AK |
125 | } |
126 | ||
127 | cleanup() { | |
128 | trap '' 2 | |
129 | # reset MOUNTPOINT - avoid recursion | |
130 | test "$MOUNTPOINT" = "$TEMPDIR" && MOUNTPOINT="" temp_umount | |
131 | if [ -n "$REMOUNT" ]; then | |
132 | verbose "Remounting unmounted filesystem back" | |
d2010960 | 133 | dry "$MOUNT" "$VOLUME" "$MOUNTED" |
f29e7ac5 AK |
134 | fi |
135 | IFS=$IFS_OLD | |
136 | trap 2 | |
17dd04ca | 137 | |
4886fa21 ZK |
138 | test "$1" -eq 2 && verbose "Break detected" |
139 | ||
fd867543 ZK |
140 | if [ "$DO_LVRESIZE" -eq 2 ]; then |
141 | # start LVRESIZE with the filesystem modification flag | |
142 | # and allow recursive call of fsadm | |
685940c0 | 143 | _FSADM_YES=$YES |
a9382908 ZK |
144 | _FSADM_EXTOFF=$EXTOFF |
145 | export _FSADM_YES _FSADM_EXTOFF | |
fd867543 | 146 | unset FSADM_RUNNING |
53c09bce | 147 | test -n "$LVM_BINARY" && PATH=$_SAVEPATH |
d2010960 | 148 | dry exec "$LVM" lvresize $VERB $FORCE -r -L${NEWSIZE}b "$VOLUME_ORIG" |
fd867543 | 149 | fi |
53c09bce | 150 | |
829fe014 ZK |
151 | # error exit status for break |
152 | exit ${1:-1} | |
f29e7ac5 AK |
153 | } |
154 | ||
50c41b09 ZK |
155 | # convert parameter from Exa/Peta/Tera/Giga/Mega/Kilo/Bytes and blocks |
156 | # (2^(60/50/40/30/20/10/0)) | |
f29e7ac5 AK |
157 | decode_size() { |
158 | case "$1" in | |
50c41b09 ZK |
159 | *[eE]) NEWSIZE=$(( ${1%[eE]} * 1152921504606846976 )) ;; |
160 | *[pP]) NEWSIZE=$(( ${1%[pP]} * 1125899906842624 )) ;; | |
f29e7ac5 AK |
161 | *[tT]) NEWSIZE=$(( ${1%[tT]} * 1099511627776 )) ;; |
162 | *[gG]) NEWSIZE=$(( ${1%[gG]} * 1073741824 )) ;; | |
163 | *[mM]) NEWSIZE=$(( ${1%[mM]} * 1048576 )) ;; | |
164 | *[kK]) NEWSIZE=$(( ${1%[kK]} * 1024 )) ;; | |
165 | *[bB]) NEWSIZE=${1%[bB]} ;; | |
166 | *) NEWSIZE=$(( $1 * $2 )) ;; | |
167 | esac | |
168 | #NEWBLOCKCOUNT=$(round_block_size $NEWSIZE $2) | |
169 | NEWBLOCKCOUNT=$(( $NEWSIZE / $2 )) | |
17dd04ca ZK |
170 | |
171 | if [ $DO_LVRESIZE -eq 1 ]; then | |
172 | # start lvresize, but first cleanup mounted dirs | |
173 | DO_LVRESIZE=2 | |
174 | cleanup 0 | |
175 | fi | |
f29e7ac5 AK |
176 | } |
177 | ||
178 | # detect filesystem on the given device | |
179 | # dereference device name if it is symbolic link | |
180 | detect_fs() { | |
55b94bf3 | 181 | VOLUME_ORIG=$1 |
8f8c5580 ZK |
182 | VOLUME=${1/#"${DM_DEV_DIR}/"/} |
183 | VOLUME=$("$READLINK" $READLINK_E "$DM_DEV_DIR/$VOLUME") || error "Cannot get readlink \"$1\"" | |
55b94bf3 ZK |
184 | RVOLUME=$VOLUME |
185 | case "$RVOLUME" in | |
8f8c5580 | 186 | # hardcoded /dev since udev does not create these entries elsewhere |
55b94bf3 | 187 | /dev/dm-[0-9]*) |
8f8c5580 | 188 | read </sys/block/${RVOLUME#/dev/}/dm/name SYSVOLUME 2>&1 && VOLUME="$DM_DEV_DIR/mapper/$SYSVOLUME" |
55b94bf3 ZK |
189 | ;; |
190 | esac | |
8f8c5580 | 191 | # use null device as cache file to be sure about the result |
284f4496 | 192 | # not using option '-o value' to be compatible with older version of blkid |
8f8c5580 | 193 | FSTYPE=$("$BLKID" -c "$NULL" -s TYPE "$VOLUME") || error "Cannot get FSTYPE of \"$VOLUME\"" |
284f4496 ZK |
194 | FSTYPE=${FSTYPE##*TYPE=\"} # cut quotation marks |
195 | FSTYPE=${FSTYPE%%\"*} | |
f29e7ac5 AK |
196 | verbose "\"$FSTYPE\" filesystem found on \"$VOLUME\"" |
197 | } | |
198 | ||
199 | # check if the given device is already mounted and where | |
55b94bf3 | 200 | # FIXME: resolve swap usage and device stacking |
f29e7ac5 | 201 | detect_mounted() { |
d2010960 | 202 | test -e "$PROCMOUNTS" || error "Cannot detect mounted device \"$VOLUME\"" |
55b94bf3 | 203 | |
a9382908 | 204 | MOUNTED=$("$GREP" "^$VOLUME[ \t]" "$PROCMOUNTS") |
55b94bf3 ZK |
205 | |
206 | # for empty string try again with real volume name | |
a9382908 | 207 | test -z "$MOUNTED" && MOUNTED=$("$GREP" "^$RVOLUME[ \t]" "$PROCMOUNTS") |
55b94bf3 ZK |
208 | |
209 | # cut device name prefix and trim everything past mountpoint | |
210 | # echo translates \040 to spaces | |
211 | MOUNTED=${MOUNTED#* } | |
212 | MOUNTED=$(echo -n -e ${MOUNTED%% *}) | |
a9d6333b ZK |
213 | |
214 | # for systems with different device names - check also mount output | |
215 | if test -z "$MOUNTED" ; then | |
a9382908 ZK |
216 | MOUNTED=$(LANG=C "$MOUNT" | "$GREP" "^$VOLUME[ \t]") |
217 | test -z "$MOUNTED" && MOUNTED=$(LANG=C "$MOUNT" | "$GREP" "^$RVOLUME[ \t]") | |
a9d6333b ZK |
218 | MOUNTED=${MOUNTED##* on } |
219 | MOUNTED=${MOUNTED% type *} # allow type in the mount name | |
220 | fi | |
221 | ||
f29e7ac5 AK |
222 | test -n "$MOUNTED" |
223 | } | |
224 | ||
225 | # get the full size of device in bytes | |
226 | detect_device_size() { | |
9ad2ba2a | 227 | # check if blockdev supports getsize64 |
8f8c5580 | 228 | "$BLOCKDEV" 2>&1 | "$GREP" getsize64 >"$NULL" |
c8669f6b | 229 | if test $? -eq 0; then |
d2010960 | 230 | DEVSIZE=$("$BLOCKDEV" --getsize64 "$VOLUME") || error "Cannot read size of device \"$VOLUME\"" |
9ad2ba2a | 231 | else |
d2010960 ZK |
232 | DEVSIZE=$("$BLOCKDEV" --getsize "$VOLUME") || error "Cannot read size of device \"$VOLUME\"" |
233 | SSSIZE=$("$BLOCKDEV" --getss "$VOLUME") || error "Cannot block size read device \"$VOLUME\"" | |
9ad2ba2a ZK |
234 | DEVSIZE=$(($DEVSIZE * $SSSIZE)) |
235 | fi | |
f29e7ac5 AK |
236 | } |
237 | ||
238 | # round up $1 / $2 | |
239 | # could be needed to gaurantee 'at least given size' | |
240 | # but it makes many troubles | |
241 | round_up_block_size() { | |
242 | echo $(( ($1 + $2 - 1) / $2 )) | |
243 | } | |
244 | ||
245 | temp_mount() { | |
d2010960 ZK |
246 | dry "$MKDIR" -p -m 0000 "$TEMPDIR" || error "Failed to create $TEMPDIR" |
247 | dry "$MOUNT" "$VOLUME" "$TEMPDIR" || error "Failed to mount $TEMPDIR" | |
f29e7ac5 AK |
248 | } |
249 | ||
250 | temp_umount() { | |
d2010960 ZK |
251 | dry "$UMOUNT" "$TEMPDIR" || error "Failed to umount \"$TEMPDIR\"" |
252 | dry "$RMDIR" "${TEMPDIR}" || error "Failed to remove \"$TEMPDIR\"" | |
253 | dry "$RMDIR" "${TEMPDIR%%m}" || error "Failed to remove \"${TEMPDIR%%m}\"" | |
f29e7ac5 AK |
254 | } |
255 | ||
256 | yes_no() { | |
257 | echo -n "$@? [Y|n] " | |
c8669f6b | 258 | |
f29e7ac5 | 259 | if [ -n "$YES" ]; then |
c8669f6b | 260 | echo y ; return 0 |
f29e7ac5 | 261 | fi |
c8669f6b ZK |
262 | |
263 | while read -r -s -n 1 ANS ; do | |
264 | case "$ANS" in | |
265 | "y" | "Y" | "") echo y ; return 0 ;; | |
266 | "n" | "N") echo n ; return 1 ;; | |
267 | esac | |
268 | done | |
f29e7ac5 AK |
269 | } |
270 | ||
271 | try_umount() { | |
d2010960 | 272 | yes_no "Do you want to unmount \"$MOUNTED\"" && dry "$UMOUNT" "$MOUNTED" && return 0 |
3a6e5f36 | 273 | error "Cannot proceed with mounted filesystem \"$MOUNTED\"" |
f29e7ac5 AK |
274 | } |
275 | ||
276 | validate_parsing() { | |
277 | test -n "$BLOCKSIZE" -a -n "$BLOCKCOUNT" || error "Cannot parse $1 output" | |
278 | } | |
279 | #################################### | |
cd96532e | 280 | # Resize ext2/ext3/ext4 filesystem |
f29e7ac5 AK |
281 | # - unmounted or mounted for upsize |
282 | # - unmounted for downsize | |
283 | #################################### | |
284 | resize_ext() { | |
285 | verbose "Parsing $TUNE_EXT -l \"$VOLUME\"" | |
d2010960 | 286 | for i in $(LANG=C "$TUNE_EXT" -l "$VOLUME"); do |
f29e7ac5 AK |
287 | case "$i" in |
288 | "Block size"*) BLOCKSIZE=${i##* } ;; | |
289 | "Block count"*) BLOCKCOUNT=${i##* } ;; | |
290 | esac | |
291 | done | |
d2010960 | 292 | validate_parsing "$TUNE_EXT" |
f29e7ac5 AK |
293 | decode_size $1 $BLOCKSIZE |
294 | FSFORCE=$FORCE | |
295 | ||
50c41b09 | 296 | if [ "$NEWBLOCKCOUNT" -lt "$BLOCKCOUNT" -o "$EXTOFF" -eq 1 ]; then |
f29e7ac5 AK |
297 | detect_mounted && verbose "$RESIZE_EXT needs unmounted filesystem" && try_umount |
298 | REMOUNT=$MOUNTED | |
a9d6333b ZK |
299 | if test -n "$MOUNTED" ; then |
300 | # Forced fsck -f for umounted extX filesystem. | |
301 | case "$-" in | |
d2010960 ZK |
302 | *i*) dry "$FSCK" $YES -f "$VOLUME" ;; |
303 | *) dry "$FSCK" -f -p "$VOLUME" ;; | |
a9d6333b ZK |
304 | esac |
305 | fi | |
f29e7ac5 AK |
306 | fi |
307 | ||
c8669f6b | 308 | verbose "Resizing filesystem on device \"$VOLUME\" to $NEWSIZE bytes ($BLOCKCOUNT -> $NEWBLOCKCOUNT blocks of $BLOCKSIZE bytes)" |
d2010960 | 309 | dry "$RESIZE_EXT" $FSFORCE "$VOLUME" $NEWBLOCKCOUNT |
f29e7ac5 AK |
310 | } |
311 | ||
312 | ############################# | |
313 | # Resize reiserfs filesystem | |
314 | # - unmounted for upsize | |
315 | # - unmounted for downsize | |
316 | ############################# | |
317 | resize_reiser() { | |
c8669f6b ZK |
318 | detect_mounted && verbose "ReiserFS resizes only unmounted filesystem" && try_umount |
319 | REMOUNT=$MOUNTED | |
f29e7ac5 | 320 | verbose "Parsing $TUNE_REISER \"$VOLUME\"" |
d2010960 | 321 | for i in $(LANG=C "$TUNE_REISER" "$VOLUME"); do |
f29e7ac5 AK |
322 | case "$i" in |
323 | "Blocksize"*) BLOCKSIZE=${i##*: } ;; | |
324 | "Count of blocks"*) BLOCKCOUNT=${i##*: } ;; | |
325 | esac | |
326 | done | |
d2010960 | 327 | validate_parsing "$TUNE_REISER" |
f29e7ac5 AK |
328 | decode_size $1 $BLOCKSIZE |
329 | verbose "Resizing \"$VOLUME\" $BLOCKCOUNT -> $NEWBLOCKCOUNT blocks ($NEWSIZE bytes, bs: $NEWBLOCKCOUNT)" | |
330 | if [ -n "$YES" ]; then | |
d2010960 | 331 | echo y | dry "$RESIZE_REISER" -s $NEWSIZE "$VOLUME" |
f29e7ac5 | 332 | else |
d2010960 | 333 | dry "$RESIZE_REISER" -s $NEWSIZE "$VOLUME" |
f29e7ac5 AK |
334 | fi |
335 | } | |
336 | ||
337 | ######################## | |
338 | # Resize XFS filesystem | |
339 | # - mounted for upsize | |
3a6e5f36 | 340 | # - cannot downsize |
f29e7ac5 AK |
341 | ######################## |
342 | resize_xfs() { | |
343 | detect_mounted | |
344 | MOUNTPOINT=$MOUNTED | |
345 | if [ -z "$MOUNTED" ]; then | |
346 | MOUNTPOINT=$TEMPDIR | |
347 | temp_mount || error "Cannot mount Xfs filesystem" | |
348 | fi | |
349 | verbose "Parsing $TUNE_XFS \"$MOUNTPOINT\"" | |
d2010960 | 350 | for i in $(LANG=C "$TUNE_XFS" "$MOUNTPOINT"); do |
f29e7ac5 AK |
351 | case "$i" in |
352 | "data"*) BLOCKSIZE=${i##*bsize=} ; BLOCKCOUNT=${i##*blocks=} ;; | |
353 | esac | |
354 | done | |
355 | BLOCKSIZE=${BLOCKSIZE%%[^0-9]*} | |
356 | BLOCKCOUNT=${BLOCKCOUNT%%[^0-9]*} | |
d2010960 | 357 | validate_parsing "$TUNE_XFS" |
f29e7ac5 AK |
358 | decode_size $1 $BLOCKSIZE |
359 | if [ $NEWBLOCKCOUNT -gt $BLOCKCOUNT ]; then | |
360 | verbose "Resizing Xfs mounted on \"$MOUNTPOINT\" to fill device \"$VOLUME\"" | |
d2010960 | 361 | dry "$RESIZE_XFS" $MOUNTPOINT |
f29e7ac5 AK |
362 | elif [ $NEWBLOCKCOUNT -eq $BLOCKCOUNT ]; then |
363 | verbose "Xfs filesystem already has the right size" | |
364 | else | |
365 | error "Xfs filesystem shrinking is unsupported" | |
366 | fi | |
367 | } | |
368 | ||
369 | #################### | |
370 | # Resize filesystem | |
371 | #################### | |
372 | resize() { | |
17dd04ca | 373 | NEWSIZE=$2 |
f29e7ac5 AK |
374 | detect_fs "$1" |
375 | detect_device_size | |
c8669f6b | 376 | verbose "Device \"$VOLUME\" size is $DEVSIZE bytes" |
f29e7ac5 | 377 | # if the size parameter is missing use device size |
17dd04ca | 378 | #if [ -n "$NEWSIZE" -a $NEWSIZE < |
50c41b09 | 379 | test -z "$NEWSIZE" && NEWSIZE=${DEVSIZE}b |
33048414 | 380 | IFS=$NL |
f29e7ac5 | 381 | case "$FSTYPE" in |
cd96532e | 382 | "ext3"|"ext2"|"ext4") resize_ext $NEWSIZE ;; |
f29e7ac5 AK |
383 | "reiserfs") resize_reiser $NEWSIZE ;; |
384 | "xfs") resize_xfs $NEWSIZE ;; | |
385 | *) error "Filesystem \"$FSTYPE\" on device \"$VOLUME\" is not supported by this tool" ;; | |
386 | esac || error "Resize $FSTYPE failed" | |
17dd04ca | 387 | cleanup 0 |
f29e7ac5 AK |
388 | } |
389 | ||
a9d6333b ZK |
390 | #################################### |
391 | # Calclulate diff between two dates | |
392 | # LANG=C input is expected the | |
393 | # only one supported | |
394 | #################################### | |
395 | diff_dates() { | |
8f8c5580 | 396 | echo $(( $("$DATE" -u -d"$1" +%s 2>"$NULL") - $("$DATE" -u -d"$2" +%s 2>"$NULL") )) |
a9d6333b ZK |
397 | } |
398 | ||
f29e7ac5 AK |
399 | ################### |
400 | # Check filesystem | |
401 | ################### | |
402 | check() { | |
403 | detect_fs "$1" | |
4886fa21 ZK |
404 | if detect_mounted ; then |
405 | verbose "Skipping filesystem check for device \"$VOLUME\" as the filesystem is mounted on $MOUNTED"; | |
406 | cleanup 3 | |
407 | fi | |
a9d6333b ZK |
408 | |
409 | case "$FSTYPE" in | |
410 | "ext2"|"ext3"|"ext4") | |
411 | IFS_CHECK=$IFS | |
412 | IFS=$NL | |
d2010960 | 413 | for i in $(LANG=C "$TUNE_EXT" -l "$VOLUME"); do |
a9d6333b ZK |
414 | case "$i" in |
415 | "Last mount"*) LASTMOUNT=${i##*: } ;; | |
416 | "Last checked"*) LASTCHECKED=${i##*: } ;; | |
417 | esac | |
418 | done | |
419 | case "$LASTMOUNT" in | |
420 | *"n/a") ;; # nothing to do - system was not mounted yet | |
421 | *) | |
422 | LASTDIFF=$(diff_dates $LASTMOUNT $LASTCHECKED) | |
423 | if test "$LASTDIFF" -gt 0 ; then | |
424 | verbose "Filesystem has not been checked after the last mount, using fsck -f" | |
425 | FORCE="-f" | |
426 | fi | |
427 | ;; | |
428 | esac | |
429 | IFS=$IFS_CHECK | |
430 | esac | |
431 | ||
f29e7ac5 | 432 | case "$FSTYPE" in |
d2010960 | 433 | "xfs") dry "$XFS_CHECK" "$VOLUME" ;; |
bd79af9f ZK |
434 | *) # check if executed from interactive shell environment |
435 | case "$-" in | |
d2010960 ZK |
436 | *i*) dry "$FSCK" $YES $FORCE "$VOLUME" ;; |
437 | *) dry "$FSCK" $FORCE -p "$VOLUME" ;; | |
bd79af9f | 438 | esac |
f29e7ac5 AK |
439 | esac |
440 | } | |
441 | ||
442 | ############################# | |
443 | # start point of this script | |
444 | # - parsing parameters | |
445 | ############################# | |
4886fa21 | 446 | trap "cleanup 2" 2 |
50c41b09 | 447 | |
17dd04ca ZK |
448 | # test if we are not invoked recursively |
449 | test -n "$FSADM_RUNNING" && exit 0 | |
450 | ||
50c41b09 ZK |
451 | # test some prerequisities |
452 | test -n "$TUNE_EXT" -a -n "$RESIZE_EXT" -a -n "$TUNE_REISER" -a -n "$RESIZE_REISER" \ | |
453 | -a -n "$TUNE_XFS" -a -n "$RESIZE_XFS" -a -n "$MOUNT" -a -n "$UMOUNT" -a -n "$MKDIR" \ | |
454 | -a -n "$RMDIR" -a -n "$BLOCKDEV" -a -n "$BLKID" -a -n "$GREP" -a -n "$READLINK" \ | |
dd96ceda | 455 | -a -n "$DATE" -a -n "$FSCK" -a -n "$XFS_CHECK" -a -n "$LVM" \ |
17dd04ca | 456 | || error "Required command definitions in the script are missing!" |
9ad2ba2a | 457 | |
8f8c5580 ZK |
458 | "$LVM" version >"$NULL" 2>&1 || error "Could not run lvm binary \"$LVM\"" |
459 | $("$READLINK" -e / >"$NULL" 2>&1) || READLINK_E="-f" | |
50c41b09 | 460 | TEST64BIT=$(( 1000 * 1000000000000 )) |
d2010960 | 461 | test "$TEST64BIT" -eq 1000000000000000 || error "Shell does not handle 64bit arithmetic" |
8f8c5580 | 462 | $(echo Y | "$GREP" Y >"$NULL") || error "Grep does not work properly" |
d2010960 | 463 | test $("$DATE" -u -d"Jan 01 00:00:01 1970" +%s) -eq 1 || error "Date translation does not work" |
50c41b09 ZK |
464 | |
465 | ||
c8669f6b | 466 | if [ "$#" -eq 0 ] ; then |
f29e7ac5 AK |
467 | tool_usage |
468 | fi | |
469 | ||
c8669f6b | 470 | while [ "$#" -ne 0 ] |
f29e7ac5 | 471 | do |
c8669f6b ZK |
472 | case "$1" in |
473 | "") ;; | |
474 | "-h"|"--help") tool_usage ;; | |
475 | "-v"|"--verbose") VERB="-v" ;; | |
476 | "-n"|"--dry-run") DRY=1 ;; | |
477 | "-f"|"--force") FORCE="-f" ;; | |
478 | "-e"|"--ext-offline") EXTOFF=1 ;; | |
479 | "-y"|"--yes") YES="-y" ;; | |
480 | "-l"|"--lvresize") DO_LVRESIZE=1 ;; | |
481 | "check") CHECK="$2" ; shift ;; | |
482 | "resize") RESIZE="$2"; NEWSIZE="$3" ; shift 2 ;; | |
483 | *) error "Wrong argument \"$1\". (see: $TOOL --help)" | |
f29e7ac5 AK |
484 | esac |
485 | shift | |
486 | done | |
487 | ||
a9382908 ZK |
488 | test "$YES" = "-y" || YES= |
489 | test "$EXTOFF" -eq 1 || EXTOFF=0 | |
490 | ||
f29e7ac5 AK |
491 | if [ -n "$CHECK" ]; then |
492 | check "$CHECK" | |
493 | elif [ -n "$RESIZE" ]; then | |
17dd04ca | 494 | export FSADM_RUNNING="fsadm" |
f29e7ac5 AK |
495 | resize "$RESIZE" "$NEWSIZE" |
496 | else | |
497 | error "Missing command. (see: $TOOL --help)" | |
498 | fi |