Print this page
XXX Remove nawk(1)
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/cmd/boot/scripts/create_ramdisk.ksh
+++ new/usr/src/cmd/boot/scripts/create_ramdisk.ksh
1 1 #!/bin/ksh -p
2 2 #
3 3 # CDDL HEADER START
4 4 #
5 5 # The contents of this file are subject to the terms of the
6 6 # Common Development and Distribution License (the "License").
7 7 # You may not use this file except in compliance with the License.
8 8 #
9 9 # You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 10 # or http://www.opensolaris.org/os/licensing.
11 11 # See the License for the specific language governing permissions
12 12 # and limitations under the License.
13 13 #
14 14 # When distributing Covered Code, include this CDDL HEADER in each
15 15 # file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 16 # If applicable, add the following below this CDDL HEADER, with the
17 17 # fields enclosed by brackets "[]" replaced with your own identifying
18 18 # information: Portions Copyright [yyyy] [name of copyright owner]
19 19 #
20 20 # CDDL HEADER END
21 21 #
22 22
23 23 # Copyright 2009 Sun Microsystems, Inc. All rights reserved.
24 24 # Use is subject to license terms.
25 25
26 26 format=ufs
27 27 ALT_ROOT=
28 28 EXTRACT_ARGS=
29 29 compress=yes
30 30 SPLIT=unknown
31 31 ERROR=0
32 32 dirsize32=0
33 33 dirsize64=0
34 34
35 35 usage() {
36 36 echo "This utility is a component of the bootadm(1M) implementation"
37 37 echo "and it is not recommended for stand-alone use."
38 38 echo "Please use bootadm(1M) instead."
39 39 echo ""
40 40 echo "Usage: ${0##*/}: [-R \<root\>] [-p \<platform\>] [--nocompress]"
41 41 echo "where \<platform\> is one of i86pc, sun4u or sun4v"
42 42 exit
43 43 }
44 44
45 45 # default platform is what we're running on
46 46 PLATFORM=`uname -m`
47 47
48 48 #
49 49 # set path, but inherit /tmp/bfubin if owned by
50 50 # same uid executing this process, which must be root.
51 51 #
52 52 if [ "`echo $PATH | cut -f 1 -d :`" = /tmp/bfubin ] && \
53 53 [ -O /tmp/bfubin ] ; then
54 54 export PATH=/tmp/bfubin
55 55 export GZIP_CMD=/tmp/bfubin/gzip
56 56 else
57 57 export PATH=/usr/sbin:/usr/bin:/sbin
58 58 export GZIP_CMD=/usr/bin/gzip
59 59 fi
60 60
61 61 EXTRACT_FILELIST="/boot/solaris/bin/extract_boot_filelist"
62 62
63 63 #
64 64 # Parse options
65 65 #
66 66 while [ "$1" != "" ]
67 67 do
68 68 case $1 in
69 69 -R) shift
70 70 ALT_ROOT="$1"
71 71 if [ "$ALT_ROOT" != "/" ]; then
72 72 echo "Creating boot_archive for $ALT_ROOT"
73 73 EXTRACT_ARGS="${EXTRACT_ARGS} -R ${ALT_ROOT}"
74 74 EXTRACT_FILELIST="${ALT_ROOT}${EXTRACT_FILELIST}"
75 75 fi
76 76 ;;
77 77 -n|--nocompress) compress=no
78 78 ;;
79 79 -p) shift
80 80 PLATFORM="$1"
81 81 EXTRACT_ARGS="${EXTRACT_ARGS} -p ${PLATFORM}"
82 82 ;;
83 83 *) usage
84 84 ;;
85 85 esac
86 86 shift
87 87 done
88 88
89 89 if [ -x /usr/bin/mkisofs -o -x /tmp/bfubin/mkisofs ] ; then
90 90 format=isofs
91 91 fi
92 92
93 93 #
94 94 # mkisofs on s8 doesn't support functionality used by GRUB boot.
95 95 # Use ufs format for boot archive instead.
96 96 #
97 97 release=`uname -r`
98 98 if [ "$release" = "5.8" ]; then
99 99 format=ufs
100 100 fi
101 101
102 102 shift `expr $OPTIND - 1`
103 103
104 104 if [ $# -eq 1 ]; then
105 105 ALT_ROOT="$1"
106 106 echo "Creating boot_archive for $ALT_ROOT"
107 107 fi
108 108
109 109 case $PLATFORM in
110 110 i386) PLATFORM=i86pc
111 111 ISA=i386
112 112 ARCH64=amd64
113 113 ;;
114 114 i86pc) ISA=i386
115 115 ARCH64=amd64
116 116 ;;
117 117 sun4u) ISA=sparc
118 118 ARCH64=sparcv9
119 119 ;;
120 120 sun4v) ISA=sparc
121 121 ARCH64=sparcv9
122 122 ;;
123 123 *) usage
124 124 ;;
125 125 esac
126 126
127 127 BOOT_ARCHIVE=platform/$PLATFORM/boot_archive
128 128 BOOT_ARCHIVE_64=platform/$PLATFORM/$ARCH64/boot_archive
129 129
130 130 if [ $PLATFORM = i86pc ] ; then
131 131 if [ ! -x "$ALT_ROOT"/boot/solaris/bin/symdef ]; then
132 132 # no dboot implies combined archives for example
133 133 # live-upgrade from s9 to s10u6 is multiboot-only
134 134 echo "Creating single archive at $ALT_ROOT/$BOOT_ARCHIVE"
135 135 SPLIT=no
136 136 compress=no
137 137 else
138 138 SPLIT=yes
139 139 fi
140 140 else # must be sparc
141 141 SPLIT=no # there's only 64-bit (sparcv9), so don't split
142 142 compress=no
143 143 fi
144 144
145 145 [ -x $GZIP_CMD ] || compress=no
146 146
147 147 function cleanup
148 148 {
149 149 umount -f "$rdmnt32" 2>/dev/null
150 150 umount -f "$rdmnt64" 2>/dev/null
151 151 lofiadm -d "$rdfile32" 2>/dev/null
|
↓ open down ↓ |
151 lines elided |
↑ open up ↑ |
152 152 lofiadm -d "$rdfile64" 2>/dev/null
153 153 [ -n "$rddir" ] && rm -fr "$rddir" 2> /dev/null
154 154 [ -n "$new_rddir" ] && rm -fr "$new_rddir" 2>/dev/null
155 155 }
156 156
157 157 function getsize
158 158 {
159 159 # Estimate image size and add 10% overhead for ufs stuff.
160 160 # Note, we can't use du here in case we're on a filesystem, e.g. zfs,
161 161 # in which the disk usage is less than the sum of the file sizes.
162 - # The nawk code
162 + # The awk code
163 163 #
164 164 # {t += ($5 % 1024) ? (int($5 / 1024) + 1) * 1024 : $5}
165 165 #
166 166 # below rounds up the size of a file/directory, in bytes, to the
167 167 # next multiple of 1024. This mimics the behavior of ufs especially
168 168 # with directories. This results in a total size that's slightly
169 169 # bigger than if du was called on a ufs directory.
170 170 size32=$(cat "$list32" | xargs -I {} ls -lLd "{}" 2> /dev/null |
171 - nawk '{t += ($5 % 1024) ? (int($5 / 1024) + 1) * 1024 : $5}
171 + /usr/xpg4/bin/awk '{t += ($5 % 1024) ? (int($5 / 1024) + 1) * 1024 : $5}
172 172 END {print int(t * 1.10 / 1024)}')
173 173 (( size32 += dirsize32 ))
174 174 size64=$(cat "$list64" | xargs -I {} ls -lLd "{}" 2> /dev/null |
175 - nawk '{t += ($5 % 1024) ? (int($5 / 1024) + 1) * 1024 : $5}
175 + /usr/xpg4/bin/awk '{t += ($5 % 1024) ? (int($5 / 1024) + 1) * 1024 : $5}
176 176 END {print int(t * 1.10 / 1024)}')
177 177 (( size64 += dirsize64 ))
178 178 (( total_size = size32 + size64 ))
179 179
180 180 if [ $compress = yes ] ; then
181 - total_size=`echo $total_size | nawk '{print int($1 / 2)}'`
181 + total_size=`echo $total_size | /usr/xpg4/bin/awk '{print int($1 / 2)}'`
182 182 fi
183 183 }
184 184
185 185 #
186 186 # Copies all desired files to a target directory. One argument should be
187 187 # passed: the file containing the list of files to copy. This function also
188 188 # depends on several variables that must be set before calling:
189 189 #
190 190 # $ALT_ROOT - the target directory
191 191 # $compress - whether or not the files in the archives should be compressed
192 192 # $rdmnt - the target directory
193 193 #
194 194 function copy_files
195 195 {
196 196 list="$1"
197 197
198 198 #
199 199 # If compress is set, the files are gzip'd and put in the correct
200 200 # location in the loop. Nothing is printed, so the pipe and cpio
201 201 # at the end is a nop.
202 202 #
203 203 # If compress is not set, the file names are printed, which causes
204 204 # the cpio at the end to do the copy.
205 205 #
206 206 while read path
207 207 do
208 208 if [ $compress = yes ]; then
209 209 dir="${path%/*}"
210 210 [ -d "$rdmnt/$dir" ] || mkdir -p "$rdmnt/$dir"
211 211 $GZIP_CMD -c "$path" > "$rdmnt/$path"
212 212 else
213 213 print "$path"
214 214 fi
215 215 done <"$list" | cpio -pdum "$rdmnt" 2>/dev/null
216 216
217 217 if [ $ISA = sparc ] ; then
218 218 # copy links
219 219 find $filelist -type l -print 2>/dev/null |\
220 220 cpio -pdum "$rdmnt" 2>/dev/null
221 221 if [ $compress = yes ] ; then
222 222 # always copy unix uncompressed
223 223 find $filelist -name unix -type f -print 2>/dev/null |\
224 224 cpio -pdum "$rdmnt" 2>/dev/null
225 225 fi
226 226 fi
227 227
228 228 }
229 229
230 230 #
231 231 # The first argument can be:
232 232 #
233 233 # "both" - create an archive with both 32-bit and 64-bit binaries
234 234 # "32-bit" - create an archive with only 32-bit binaries
235 235 # "64-bit" - create an archive with only 64-bit binaries
236 236 #
237 237 function create_ufs
238 238 {
239 239 which=$1
240 240 archive=$2
241 241 lofidev=$3
242 242
243 243 # should we exclude amd64 binaries?
244 244 if [ "$which" = "32-bit" ]; then
245 245 rdfile="$rdfile32"
246 246 rdmnt="$rdmnt32"
247 247 list="$list32"
248 248 elif [ "$which" = "64-bit" ]; then
249 249 rdfile="$rdfile64"
250 250 rdmnt="$rdmnt64"
251 251 list="$list64"
252 252 else
253 253 rdfile="$rdfile32"
254 254 rdmnt="$rdmnt32"
255 255 list="$list32"
256 256 fi
257 257
258 258 newfs $lofidev < /dev/null 2> /dev/null
259 259 mkdir "$rdmnt"
260 260 mount -F mntfs mnttab /etc/mnttab > /dev/null 2>&1
261 261 mount -F ufs -o nologging $lofidev "$rdmnt"
262 262 files=
263 263
264 264 # do the actual copy
265 265 copy_files "$list"
266 266 umount -f "$rdmnt"
267 267 rmdir "$rdmnt"
268 268
269 269 if [ $ISA = sparc ] ; then
270 270 rlofidev=`echo "$lofidev" | sed -e "s/dev\/lofi/dev\/rlofi/"`
271 271 bb="$ALT_ROOT/platform/$PLATFORM/lib/fs/ufs/bootblk"
272 272 # installboot is not available on all platforms
273 273 dd if=$bb of=$rlofidev bs=1b oseek=1 count=15 conv=sync 2>&1
274 274 fi
275 275
276 276 #
277 277 # Check if gzip exists in /usr/bin, so we only try to run gzip
278 278 # on systems that have gzip. Then run gzip out of the patch to
279 279 # pick it up from bfubin or something like that if needed.
280 280 #
281 281 # If compress is set, the individual files in the archive are
282 282 # compressed, and the final compression will accomplish very
283 283 # little. To save time, we skip the gzip in this case.
284 284 #
285 285 if [ $ISA = i386 ] && [ $compress = no ] && \
286 286 [ -x $GZIP_CMD ] ; then
287 287 gzip -c "$rdfile" > "${archive}-new"
288 288 else
289 289 cat "$rdfile" > "${archive}-new"
290 290 fi
291 291
292 292 if [ $? -ne 0 ] ; then
293 293 rm -f "${archive}-new"
294 294 fi
295 295 }
296 296
297 297 #
298 298 # The first argument can be:
299 299 #
300 300 # "both" - create an archive with both 32-bit and 64-bit binaries
301 301 # "32-bit" - create an archive with only 32-bit binaries
302 302 # "64-bit" - create an archive with only 64-bit binaries
303 303 #
304 304 function create_isofs
305 305 {
306 306 which=$1
307 307 archive=$2
308 308
309 309 # should we exclude amd64 binaries?
310 310 if [ "$which" = "32-bit" ]; then
311 311 rdmnt="$rdmnt32"
312 312 errlog="$errlog32"
313 313 list="$list32"
314 314 elif [ "$which" = "64-bit" ]; then
315 315 rdmnt="$rdmnt64"
316 316 errlog="$errlog64"
317 317 list="$list64"
318 318 else
319 319 rdmnt="$rdmnt32"
320 320 errlog="$errlog32"
321 321 list="$list32"
322 322 fi
323 323
324 324 # create image directory seed with graft points
325 325 mkdir "$rdmnt"
326 326 files=
327 327 isocmd="mkisofs -quiet -graft-points -dlrDJN -relaxed-filenames"
328 328
329 329 if [ $ISA = sparc ] ; then
330 330 bb="$ALT_ROOT/platform/$PLATFORM/lib/fs/hsfs/bootblk"
331 331 isocmd="$isocmd -G \"$bb\""
332 332 fi
333 333
334 334 copy_files "$list"
335 335 isocmd="$isocmd \"$rdmnt\""
336 336 rm -f "$errlog"
337 337
338 338 #
339 339 # Check if gzip exists in /usr/bin, so we only try to run gzip
340 340 # on systems that have gzip. Then run gzip out of the patch to
341 341 # pick it up from bfubin or something like that if needed.
342 342 #
343 343 # If compress is set, the individual files in the archive are
344 344 # compressed, and the final compression will accomplish very
345 345 # little. To save time, we skip the gzip in this case.
346 346 #
347 347 mkiso_ret=0
348 348
349 349 if [ $ISA = i386 ] &&[ $compress = no ] && [ -x $GZIP_CMD ]
350 350 then
351 351 ksh -c "$isocmd" 2> "$errlog" | \
352 352 gzip > "${archive}-new"
353 353 else
354 354 ksh -c "$isocmd" 2> "$errlog" > "${archive}-new"
355 355 fi
356 356
357 357 if [ $? -ne 0 ]; then
358 358 cat "$errlog"
359 359 rm -f "${archive}-new" 2> /dev/null
360 360 rm -f "$errlog" 2> /dev/null
361 361 return
362 362 fi
363 363
364 364 dd_ret=0
365 365 if [ $ISA = sparc ] ; then
366 366 bb="$ALT_ROOT/platform/$PLATFORM/lib/fs/hsfs/bootblk"
367 367 dd if="$bb" of="${archive}-new" bs=1b oseek=1 count=15 \
368 368 conv=notrunc conv=sync >> "$errlog" 2>&1
369 369 dd_ret=$?
370 370 fi
371 371
372 372 if [ -s "$errlog" ] || [ $dd_ret -ne 0 ] ; then
373 373 grep Error: "$errlog" >/dev/null 2>&1
374 374 if [ $? -eq 0 ] || [ $dd_ret -ne 0 ] ; then
375 375 cat "$errlog"
376 376 rm -f "${archive}-new"
377 377 fi
378 378 fi
379 379 rm -f "$errlog"
380 380 }
381 381
382 382 function create_archive
383 383 {
384 384 which=$1
385 385 archive=$2
386 386 lofidev=$3
387 387
|
↓ open down ↓ |
196 lines elided |
↑ open up ↑ |
388 388 echo "updating $archive"
389 389
390 390 if [ "$format" = "ufs" ]; then
391 391 create_ufs "$which" "$archive" "$lofidev"
392 392 else
393 393 create_isofs "$which" "$archive"
394 394 fi
395 395
396 396 # sanity check the archive before moving it into place
397 397 #
398 - ARCHIVE_SIZE=`ls -l "${archive}-new" 2> /dev/null | nawk '{ print $5 }'`
398 + ARCHIVE_SIZE=`ls -l "${archive}-new" 2> /dev/null | /usr/xpg4/bin/awk '{ print $5 }'`
399 399 if [ $compress = yes ] || [ $ISA = sparc ] ; then
400 400 #
401 401 # 'file' will report "English text" for uncompressed
402 402 # boot_archives. Checking for that doesn't seem stable,
403 403 # so we just check that the file exists.
404 404 #
405 405 ls "${archive}-new" >/dev/null 2>&1
406 406 else
407 407 #
408 408 # the file type check also establishes that the
409 409 # file exists at all
410 410 #
411 411 LC_MESSAGES=C file "${archive}-new" | grep gzip > /dev/null
412 412 fi
413 413
414 414 if [ $? = 1 ] && [ -x $GZIP_CMD ] || [ "$ARCHIVE_SIZE" -lt 10000 ]
415 415 then
416 416 #
417 417 # Two of these functions may be run in parallel. We
418 418 # need to allow the other to clean up, so we can't
419 419 # exit immediately. Instead, we set a flag.
420 420 #
421 421 echo "update of $archive failed"
422 422 ERROR=1
423 423 else
424 424 lockfs -f "/$ALT_ROOT" 2>/dev/null
425 425 mv "${archive}-new" "$archive"
426 426 lockfs -f "/$ALT_ROOT" 2>/dev/null
427 427 fi
428 428
429 429 }
430 430
431 431 function fatal_error
432 432 {
433 433 print -u2 $*
434 434 exit 1
435 435 }
436 436
437 437 #
438 438 # get filelist
439 439 #
440 440 if [ ! -f "$ALT_ROOT/boot/solaris/filelist.ramdisk" ] &&
441 441 [ ! -f "$ALT_ROOT/etc/boot/solaris/filelist.ramdisk" ]
442 442 then
443 443 print -u2 "Can't find filelist.ramdisk"
444 444 exit 1
445 445 fi
446 446 filelist=$($EXTRACT_FILELIST $EXTRACT_ARGS \
447 447 /boot/solaris/filelist.ramdisk \
448 448 /etc/boot/solaris/filelist.ramdisk \
449 449 2>/dev/null | sort -u)
450 450
451 451 #
452 452 # We use /tmp/ for scratch space now. This may be changed later if there
453 453 # is insufficient space in /tmp/.
454 454 #
455 455 rddir="/tmp/create_ramdisk.$$.tmp"
456 456 new_rddir=
457 457 rm -rf "$rddir"
458 458 mkdir "$rddir" || fatal_error "Could not create temporary directory $rddir"
459 459
460 460 # Clean up upon exit.
461 461 trap 'cleanup' EXIT
462 462
463 463 list32="$rddir/filelist.32"
464 464 list64="$rddir/filelist.64"
465 465
466 466 touch $list32 $list64
467 467
468 468 #
469 469 # This loop creates the 32-bit and 64-bit lists of files. The 32-bit list
|
↓ open down ↓ |
61 lines elided |
↑ open up ↑ |
470 470 # is written to stdout, which is redirected at the end of the loop. The
471 471 # 64-bit list is appended with each write.
472 472 #
473 473 cd "/$ALT_ROOT"
474 474 find $filelist -print 2>/dev/null | while read path
475 475 do
476 476 if [ $SPLIT = no ]; then
477 477 print "$path"
478 478 elif [ -d "$path" ]; then
479 479 if [ $format = ufs ]; then
480 - size=`ls -lLd "$path" | nawk '
480 + size=`ls -lLd "$path" | /usr/xpg4/bin/awk '
481 481 {print ($5 % 1024) ? (int($5 / 1024) + 1) * 1024 : $5}'`
482 482 if [ `basename "$path"` != "amd64" ]; then
483 483 (( dirsize32 += size ))
484 484 fi
485 485 (( dirsize64 += size ))
486 486 fi
487 487 else
488 488 case `LC_MESSAGES=C /usr/bin/file -m /dev/null "$path" 2>/dev/null` in
489 489 *ELF\ 64-bit*)
490 490 print "$path" >> "$list64"
491 491 ;;
492 492 *ELF\ 32-bit*)
493 493 print "$path"
494 494 ;;
495 495 *)
496 496 # put in both lists
497 497 print "$path"
498 498 print "$path" >> "$list64"
499 499 esac
500 500 fi
501 501 done >"$list32"
502 502
503 503 if [ $format = ufs ] ; then
504 504 # calculate image size
505 505 getsize
506 506
507 507 # check to see if there is sufficient space in tmpfs
508 508 #
509 509 tmp_free=`df -b /tmp | tail -1 | awk '{ printf ($2) }'`
510 510 (( tmp_free = tmp_free / 3 ))
511 511 if [ $SPLIT = yes ]; then
512 512 (( tmp_free = tmp_free / 2 ))
513 513 fi
514 514
515 515 if [ $total_size -gt $tmp_free ] ; then
516 516 # assumes we have enough scratch space on $ALT_ROOT
517 517 new_rddir="/$ALT_ROOT/var/tmp/create_ramdisk.$$.tmp"
518 518 rm -rf "$new_rddir"
519 519 mkdir "$new_rddir" || fatal_error \
520 520 "Could not create temporary directory $new_rddir"
521 521
522 522 # Save the file lists
523 523 mv "$list32" "$new_rddir"/
524 524 mv "$list64" "$new_rddir"/
525 525 list32="/$new_rddir/filelist.32"
526 526 list64="/$new_rddir/filelist.64"
527 527
528 528 # Remove the old $rddir and set the new value of rddir
529 529 rm -rf "$rddir"
530 530 rddir="$new_rddir"
531 531 new_rddir=
532 532 fi
533 533 fi
534 534
535 535 rdfile32="$rddir/rd.file.32"
536 536 rdfile64="$rddir/rd.file.64"
537 537 rdmnt32="$rddir/rd.mount.32"
538 538 rdmnt64="$rddir/rd.mount.64"
539 539 errlog32="$rddir/rd.errlog.32"
540 540 errlog64="$rddir/rd.errlog.64"
541 541 lofidev32=""
542 542 lofidev64=""
543 543
544 544 if [ $SPLIT = yes ]; then
545 545 #
546 546 # We can't run lofiadm commands in parallel, so we have to do
547 547 # them here.
548 548 #
549 549 if [ "$format" = "ufs" ]; then
550 550 mkfile ${size32}k "$rdfile32"
551 551 lofidev32=`lofiadm -a "$rdfile32"`
552 552 mkfile ${size64}k "$rdfile64"
553 553 lofidev64=`lofiadm -a "$rdfile64"`
554 554 fi
555 555 create_archive "32-bit" "$ALT_ROOT/$BOOT_ARCHIVE" $lofidev32 &
556 556 create_archive "64-bit" "$ALT_ROOT/$BOOT_ARCHIVE_64" $lofidev64
557 557 wait
558 558 if [ "$format" = "ufs" ]; then
559 559 lofiadm -d "$rdfile32"
560 560 lofiadm -d "$rdfile64"
561 561 fi
562 562 else
563 563 if [ "$format" = "ufs" ]; then
564 564 mkfile ${total_size}k "$rdfile32"
565 565 lofidev32=`lofiadm -a "$rdfile32"`
566 566 fi
567 567 create_archive "both" "$ALT_ROOT/$BOOT_ARCHIVE" $lofidev32
568 568 [ "$format" = "ufs" ] && lofiadm -d "$rdfile32"
569 569 fi
570 570 if [ $ERROR = 1 ]; then
571 571 cleanup
572 572 exit 1
573 573 fi
574 574
575 575 #
576 576 # For the diskless case, hardlink archive to /boot to make it
577 577 # visible via tftp. /boot is lofs mounted under /tftpboot/<hostname>.
578 578 # NOTE: this script must work on both client and server.
579 579 #
580 580 grep "[ ]/[ ]*nfs[ ]" "$ALT_ROOT/etc/vfstab" > /dev/null
581 581 if [ $? = 0 ]; then
582 582 rm -f "$ALT_ROOT/boot/boot_archive" "$ALT_ROOT/boot/amd64/boot_archive"
583 583 ln "$ALT_ROOT/$BOOT_ARCHIVE" "$ALT_ROOT/boot/boot_archive"
584 584 if [ $SPLIT = yes ]; then
585 585 ln "$ALT_ROOT/$BOOT_ARCHIVE_64" \
586 586 "$ALT_ROOT/boot/amd64/boot_archive"
587 587 fi
588 588 fi
589 589 [ -n "$rddir" ] && rm -rf "$rddir"
|
↓ open down ↓ |
99 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX