This file is indexed.

postinst is in grub-pc 1.99-21ubuntu3.

This file is a maintainer script. It is executed when installing (*inst) or removing (*rm) the package.

The actual contents of the file can be viewed below.

  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
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
#!/bin/bash
set -e

merge_debconf_into_conf()
{
  local tmpfile; tmpfile="$1"
  local setting; setting="$2"
  local template; template="$3"

  db_get "$template"
  local value; value="$(echo "$RET" | sed -e 's,[$`"\],\\&,g; s,[\@],\\&,g')"
  if grep -q "^${setting}=" "$tmpfile"; then
    sed -i -re "s@^(${setting}=).*@\1\"${value}\"@" "$tmpfile"
  else
    echo >> "$tmpfile"
    echo "${setting}=\"${value}\"" >> "$tmpfile"
  fi
}

get_wubi_device()
{
  if [ ! -x /usr/share/lupin-support/grub-mkimage ] || \
     ! /usr/share/lupin-support/grub-mkimage --test; then
    return 1
  fi

  local bootdev="$(grub-probe --target=device /boot)" || true
  local loop_file=
  case $bootdev in
    /dev/loop/*|/dev/loop[0-9])
      loop_file="$(losetup "$bootdev" | sed -e "s/^[^(]*(\([^)]\+\)).*/\1/")"
      # If it's loop-mounted from another device, it isn't Wubi.
      case $loop_file in
        /dev/*) return 1 ;;
      esac
    ;;
    *) return 1 ;;
  esac

  echo "$bootdev"
}

# This only works on a Linux system with udev running.  This is probably the
# vast majority of systems where we need any of this, though, and we fall
# back reasonably gracefully if we don't have it.
cached_available_ids=
available_ids()
{
  local id path

  if [ "$cached_available_ids" ]; then
    echo "$cached_available_ids"
    return
  fi

  [ -d /dev/disk/by-id ] || return
  cached_available_ids="$(
    for path in /dev/disk/by-id/*; do
      [ -e "$path" ] || continue
      printf '%s %s\n' "$path" "$(readlink -f "$path")"
    done | sort -k2 -s -u | cut -d' ' -f1
  )"
  echo "$cached_available_ids"
}

# Returns non-zero and no output if no mapping can be found.
device_to_id()
{
  local id
  for id in $(available_ids); do
    if [ "$(readlink -f "$id")" = "$(readlink -f "$1")" ]; then
      echo "$id"
      return 0
    fi
  done
  # Fall back to the plain device name if there's no by-id link for it.
  if [ -e "$1" ]; then
    echo "$1"
    return 0
  fi
  return 1
}

devices_to_ids()
{
  local device id ids
  ids=
  for device; do
    id="$(device_to_id "$device" || true)"
    if [ "$id" ]; then
      ids="${ids:+$ids, }$id"
    fi
  done
  echo "$ids"
}

all_disks()
{
  local id
  for id in $(available_ids); do
    case $id in
      *-part*) ;;
      *) echo "$id" ;;
    esac
  done
}

all_partitions()
{
  local id ids
  ids=
  for id in $(available_ids); do
    if [ "$id" != "$1" ] && [ "${id%-part*}" = "$1" ]; then
      ids="${ids:+$ids }$id"
    fi
  done
  echo "$ids"
}

# In order to determine whether we accidentally ran grub-install without
# upgrade-from-grub-legacy on versions older than 1.98+20100617-1, we need
# to be able to scan a disk to determine whether GRUB 2 was installed in its
# boot sector.  This is specific to i386-pc (but that's the only platform
# where we need it).
scan_grub2()
{
  if ! dd if="$1" bs=512 count=1 2>/dev/null | grep -aq GRUB; then
    # No version of GRUB is installed.
    return 1
  fi

  # The GRUB boot sector always starts with a JMP instruction.
  initial_jmp="$(dd if="$1" bs=2 count=1 2>/dev/null | od -Ax -tx1 | \
                 head -n1 | cut -d' ' -f2,3)"
  [ "$initial_jmp" ] || return 1
  initial_jmp_opcode="${initial_jmp%% *}"
  [ "$initial_jmp_opcode" = eb ] || return 1
  initial_jmp_operand="${initial_jmp#* }"
  case $initial_jmp_operand in
    47|4b|4c|63)
      # I believe this covers all versions of GRUB 2 up to the package
      # version where we gained a more explicit mechanism.  GRUB Legacy
      # always had 48 here.
      return 0
    ;;
  esac

  return 1
}

# for Linux
sysfs_size()
{
  local num_sectors sector_size size
  # Try to find out the size without relying on a partitioning tool being
  # installed. This isn't too hard on Linux 2.6 with sysfs, but we have to
  # try a couple of variants on detection of the sector size.
  if [ -e "$1/size" ]; then
    num_sectors="$(cat "$1/size")"
    sector_size=512
    if [ -e "$1/queue/logical_block_size" ]; then
      sector_size="$(cat "$1/queue/logical_block_size")"
    elif [ -e "$1/queue/hw_sector_size" ]; then
      sector_size="$(cat "$1/queue/hw_sector_size")"
    fi
    size="$(expr "$num_sectors" \* "$sector_size" / 1000 / 1000)"
  fi
  [ "$size" ] || size='???'
  echo "$size"
}

# for kFreeBSD
camcontrol_size()
{
  local num_sectors sector_size size=

  if num_sectors="$(camcontrol readcap "$1" -q -s -N)"; then
    sector_size="$(camcontrol readcap "$1" -q -b)"
    size="$(expr "$num_sectors" \* "$sector_size" / 1000 / 1000)"
  fi

  [ "$size" ] || size='???'
  echo "$size"
}

# Returns value in $RET, like a debconf command.
describe_disk()
{
  local disk id base size
  disk="$1"
  id="$2"

  model=
  case $(uname -s) in
    Linux)
      if which udevadm >/dev/null 2>&1; then
        size="$(sysfs_size "/sys$(udevadm info -n "$disk" -q path)")"
      else
        base="${disk#/dev/}"
        base="$(printf %s "$base" | sed 's,/,!,g')"
        size="$(sysfs_size "/sys/block/$base")"
      fi

      if which udevadm >/dev/null 2>&1; then
        model="$(udevadm info -n "$disk" -q property | sed -n 's/^ID_MODEL=//p')"
        if [ -z "$model" ]; then
          model="$(udevadm info -n "$disk" -q property | sed -n 's/^DM_NAME=//p')"
          if [ -z "$model" ]; then
            model="$(udevadm info -n "$disk" -q property | sed -n 's/^MD_NAME=//p')"
            if [ -z "$model" ] && which dmsetup >/dev/null 2>&1; then
              model="$(dmsetup info -c --noheadings -o name "$disk" 2>/dev/null || true)"
            fi
          fi
        fi
      fi
    ;;
    GNU/kFreeBSD)
      disk_basename=$(basename "$disk")
      size="$(camcontrol_size "$disk_basename")"
      model="$(camcontrol inquiry "$disk_basename" | sed -ne "s/^pass0: <\([^>]*\)>.*/\1/p")"
    ;;
  esac

  [ "$model" ] || model='???'

  db_subst grub-pc/disk_description DEVICE "$disk"
  db_subst grub-pc/disk_description SIZE "$size"
  db_subst grub-pc/disk_description MODEL "$model"
  db_metaget grub-pc/disk_description description
}

# Returns value in $RET, like a debconf command.
describe_partition()
{
  local disk part id path diskbase partbase size
  disk="$1"
  part="$2"
  id="$3"
  path="$4"

  if which udevadm >/dev/null 2>&1; then
    size="$(sysfs_size "/sys$(udevadm info -n "$part" -q path)")"
  else
    diskbase="${disk#/dev/}"
    diskbase="$(printf %s "$diskbase" | sed 's,/,!,g')"
    partbase="${part#/dev/}"
    partbase="$(printf %s "$partbase" | sed 's,/,!,g')"
    size="$(sysfs_size "/sys/block/$diskbase/$partbase")"
  fi

  db_subst grub-pc/partition_description DEVICE "$part"
  db_subst grub-pc/partition_description SIZE "$size"
  db_subst grub-pc/partition_description PATH "$path"
  db_metaget grub-pc/partition_description description
}

usable_partitions()
{
  local last_partition path partition partition_id

  last_partition=
  for path in / /boot /boot/grub; do
    partition="$(grub-probe -t device "$path" || true)"
    if [ -z "$partition" ] || [ "$partition" = "$last_partition" ]; then
      continue
    fi
    partition_id="$(device_to_id "$partition" || true)"
    echo "$path:$partition_id"
    last_partition="$partition"
  done | sort -t: -k2
}

get_mountpoint()
{
  local relpath boot_mountpoint

  relpath="$(grub-mkrelpath "$1")"
  boot_mountpoint="${1#$relpath}"
  echo "${boot_mountpoint:-/}"
}

config_item()
{
  if [ -f /etc/default/grub ]; then
    . /etc/default/grub || return
  fi
  eval echo "\$$1"
}

case "$1" in
  configure)
    . /usr/share/debconf/confmodule

    if dpkg --compare-versions "$2" lt-nl 1.99-1; then
      # Force dpkg to replace this directory with a symlink.
      if [ ! -L /usr/share/doc/grub-pc ] && [ -d /usr/share/doc/grub-pc ]; then
        if rmdir /usr/share/doc/grub-pc 2>/dev/null; then
          ln -sf grub-common /usr/share/doc/grub-pc
        fi
      fi
    fi

    devicemap_regenerated=

    if egrep -q '^[[:space:]]*post(inst|rm)_hook[[:space:]]*=[[:space:]]*(/sbin/|/usr/sbin/)?update-grub' /etc/kernel-img.conf 2>/dev/null; then
      echo 'Removing update-grub hooks from /etc/kernel-img.conf in favour of' >&2
      echo '/etc/kernel/ hooks.' >&2
      sed -ri /etc/kernel-img.conf -e '\%^[[:space:]]*post(inst|rm)_hook[[:space:]]*=[[:space:]]*(/sbin/|/usr/sbin/)?update-grub%d'
    fi

    case grub-pc in
      grub-pc)
        mkdir -p /boot/grub

        if test -e /boot/grub/device.map && ! test -e /boot/grub/core.img ; then
          # Looks like your device.map was generated by GRUB Legacy, which
          # used to generate broken device.map (see #422851).  Avoid the risk
          # by regenerating it.
          grub-mkdevicemap --no-floppy
          devicemap_regenerated=1
        fi
      ;;
    esac

    if test -z "$devicemap_regenerated" && test -s /boot/grub/device.map && \
       dpkg --compare-versions "$2" lt-nl 1.98+20100702-1 && \
       test "$(uname -s)" = Linux; then
      # Earlier versions of GRUB used unstable device names in device.map,
      # which caused a variety of problems.  There is some risk associated with
      # regenerating it (so we prompt the user if it's non-trivial), but on the
      # whole it's less risky to move to /dev/disk/by-id/.
      devicemap_lines="$(egrep -v '^[[:space:]]+#' /boot/grub/device.map | wc -l)"
      grub-mkdevicemap --no-floppy
      devicemap_regenerated=1
      if test "$devicemap_lines" != 1; then
        db_input critical grub2/device_map_regenerated || true
        db_go || true
      fi
    fi

    if test -z "$devicemap_regenerated" && \
       dpkg --compare-versions "$2" lt-nl 1.99~20101210-2 && \
       grep -qs /md-uuid- /boot/grub/device.map; then
      echo "Removing MD devices from device.map, since the BIOS cannot read from these." >&2
      sed -i '/\/md-uuid-/d' /boot/grub/device.map
    fi

    tmp_default_grub="$(mktemp -t grub.XXXXXXXXXX)"
    trap "rm -f ${tmp_default_grub}" EXIT
    cp -p /usr/share/grub/default/grub ${tmp_default_grub}

    merge_debconf_into_conf "$tmp_default_grub" GRUB_CMDLINE_LINUX grub2/linux_cmdline
    merge_debconf_into_conf "$tmp_default_grub" GRUB_CMDLINE_LINUX_DEFAULT grub2/linux_cmdline_default

    case grub-pc in
      grub-pc)
        merge_debconf_into_conf "$tmp_default_grub" GRUB_TIMEOUT grub-pc/timeout
        sed -i -e 's/^\(GRUB_TIMEOUT=\)"\([0-9][0-9]*\)"/\1\2/' "$tmp_default_grub"
        db_get grub-pc/hidden_timeout
        if [ "$RET" = false ]; then
          sed -i -e 's/^GRUB_HIDDEN_TIMEOUT=/#&/' "$tmp_default_grub"
        fi
      ;;
    esac

    ucf --three-way --debconf-ok --sum-file=/usr/share/grub/default/grub.md5sum ${tmp_default_grub} /etc/default/grub
    package="$(ucfq --with-colons /etc/default/grub | cut -d : -f 2)"
    if echo $package | grep -q "^grub-" ; then
      ucfr --force grub-pc /etc/default/grub
    else
      ucfr grub-pc /etc/default/grub
    fi

    case grub-pc in
      grub-pc)

        fix_mixed_system=
        if test -e /boot/grub/stage2 && test -e /boot/grub/menu.lst && \
           ! test -e /boot/grub/grub2-installed && \
           test -z "$UPGRADE_FROM_GRUB_LEGACY"; then
          # Unfortunately, it's still possible that the user upgraded fully
          # to GRUB 2 in some way other than running
          # upgrade-from-grub-legacy; perhaps they ran grub-install by hand
          # for some reason.  It's really quite difficult to detect this
          # situation, because the only difference between this and a
          # working chainloaded setup is that in this case grub-setup has
          # been run.  So, to try to tell the difference, we scan the boot
          # sectors of all disks for a GRUB 2 boot sector.  Hopefully this
          # won't cause too much to explode, since I can't think of a better
          # method.
          grub2_disks=
          for disk in $(all_disks); do
            if scan_grub2 "$disk"; then
              grub2_disks="${grub2_disks:+$grub2_disks }$(readlink -f "$disk")"
            fi
          done
          if [ "$grub2_disks" ]; then
            # No || true here; it's vital that the user sees this, and it's
            # better to throw an error than to do the wrong thing.
            db_subst grub-pc/mixed_legacy_and_grub2 DISKS "$grub2_disks"
            db_input critical grub-pc/mixed_legacy_and_grub2
            db_go
            db_get grub-pc/mixed_legacy_and_grub2
            if [ "$RET" = true ]; then
              db_reset grub-pc/install_devices
              UPGRADE_FROM_GRUB_LEGACY=1
              fix_mixed_system=1
              # Fall through to normal installation logic.
            fi
          fi
        fi

        # Make sure that Wubi users never see confusing device prompts.
        # Wubi is a very specialised hack that does complicated things with
        # grub-install diversions to create an image that's chained from the
        # Windows boot loader to boot an operating system from a file on a
        # Windows file system.  In these circumstances, prompting for where
        # to install GRUB is not going to help anyone.
        wubi_device="$(get_wubi_device)" || true
        if [ "$wubi_device" ]; then
          db_set grub-pc/install_devices "$wubi_device"
          db_fset grub-pc/install_devices seen true
        fi

        if test -e /boot/grub/stage2 && test -e /boot/grub/menu.lst && \
           ! test -e /boot/grub/grub2-installed && \
           test -z "$UPGRADE_FROM_GRUB_LEGACY"; then
          db_get grub-pc/chainload_from_menu.lst
          if $RET ; then
            # Create core.img (but do not risk writing to MBR).
            # Using grub-probe instead of "(hd0)" avoids (UUID=) hack slowness
            # in case /boot/grub is not on (hd0) in device.map.
            echo "Generating core.img" >&2
            grub-install --no-floppy --grub-setup=/bin/true "$(grub-probe -t drive /boot/grub)" > /dev/null

            # Update menu.lst to reflect that:
            # - core.img is present now
            # - core.img has to be the first option
            echo "Saving menu.lst backup in /boot/grub/menu.lst_backup_by_grub2_postinst" >&2
            cp /boot/grub/menu.lst{,_backup_by_grub2_postinst}
            echo "Running update-grub Legacy to hook our core.img in it" >&2
            LET_US_TRY_GRUB_2=true /usr/lib/grub-legacy/update-grub 2>&1 | sed -e "s/^/    /g" >&2
            # We just hooked GRUB 2 in menu.lst; then also generate grub.cfg.
            touch /boot/grub/grub.cfg
          fi
        elif test -z "$2" || test -e /boot/grub/core.img || \
             test "$UPGRADE_FROM_GRUB_LEGACY" || test "$wubi_device"; then
          question=grub-pc/install_devices
          device_map="$(grub-mkdevicemap -m - | grep -v '^(fd[0-9]\+)' || true)"
          devices="$(echo "$device_map" | cut -f2)"
          if dpkg --compare-versions "$2" lt 1.98~20100128-1ubuntu1 && \
             test "$(uname -s)" = Linux && [ -z "$wubi_device" ]; then
            # Migrate to new by-id naming scheme.
            db_get grub-pc/install_devices
            old_devices="$(echo "$RET" | sed 's/, / /g')"
            new_devices=
            # Common-case optimisation: if the list of devices is
            # identical to the LHS of grub-mkdevicemap's output, then
            # there's no point asking again; just install to all disks.
            # (This handles e.g. "(hd0)" with one disk.)
            if [ "$(echo "$device_map" | cut -f1 | sort)" = \
                 "$(echo "$old_devices" | xargs -n1 | sort)" ]; then
              new_devices="$(devices_to_ids $devices)"
              db_set grub-pc/install_devices "$new_devices"
            # Alternatively, we might be installing to a single partition
            # on a single disk, and we can deal with that too if there's
            # only one available disk and it has an appropriate partition.
            # This doesn't necessarily work for multiple disks because now
            # the order matters.
            elif [ "$(echo "$device_map" | wc -l)" = 1 ] && \
                 [ "$(echo "$old_devices" | wc -w)" = 1 ] && \
                 echo "$old_devices" | grep -q ,; then
              old_device="${old_devices#(}"
              old_device="${old_device%)}"
              old_disk="${old_device%,*}"
              old_partition="${old_device##*,}"
              new_device="$(echo "$device_map" | grep "^($old_disk)" | \
                            cut -f2)"
              new_device="$(device_to_id $new_device)"
              if [ "$new_device" ]; then
                new_device="$new_device-part$old_partition"
                # Run through device_to_id again to check for existence.
                new_device="$(device_to_id $new_device)"
              fi
              if [ "$new_device" ]; then
                new_devices="$new_device"
                db_set grub-pc/install_devices "$new_device"
              fi
            fi
            if [ -z "$new_devices" ]; then
              new_devices="$(devices_to_ids $old_devices)"
              db_set grub-pc/install_devices "$new_devices"
              # Common-case optimisation: if all devices are translatable
              # to by-id and the number of devices there is the same as
              # the number of devices GRUB can see, then there's no point
              # asking again.  (This handles e.g. "/dev/sda" with one
              # disk.)
              old_devices_count="$(echo "$old_devices" | wc -w)"
              new_devices_count="$(echo "$new_devices" | wc -w)"
              devices_count="$(echo "$devices" | wc -w)"
              if [ "$old_devices_count" != "$new_devices_count" ] || \
                 [ "$new_devices_count" != "$devices_count" ]; then
                db_fset grub-pc/install_devices seen false
                db_fset grub-pc/install_devices_empty seen false
              fi
            fi
          else
            db_get grub-pc/install_devices
            valid=1
            for device in $RET; do
              if [ ! -e "${device%,}" ]; then
                valid=0
                break
              fi
            done
            if [ "$valid" = 0 ]; then
              question=grub-pc/install_devices_disks_changed
              db_set "$question" "$RET"
              db_fset "$question" seen false
              db_fset grub-pc/install_devices_empty seen false
            fi
          fi

          while :; do
            ids=
            descriptions=
            partitions="$(usable_partitions)"
            for device in $devices; do
              disk_id="$(device_to_id "$device" || true)"
              if [ "$disk_id" ]; then
                ids="${ids:+$ids, }$disk_id"
                describe_disk "$(readlink -f "$device")" "$disk_id"
                RET="$(printf %s "$RET" | sed 's/,/\\,/g')"
                descriptions="${descriptions:+$descriptions, }$RET"
                for partition_pair in $partitions; do
                  partition_id="${partition_pair#*:}"
                  if [ "${partition_id#$disk_id-part}" != "$partition_id" ]; then
                    ids="${ids:+$ids, }$partition_id"
                    describe_partition "$(readlink -f "$device")" "$(readlink -f "$partition_id")" "$partition_id" "$(get_mountpoint "${partition_pair%%:*}")"
                    RET="$(printf %s "$RET" | sed 's/,/\\,/g')"
                    descriptions="${descriptions:+$descriptions, }$RET"
                  fi
                done
              fi
            done
            # Some "partitions" may in fact be at the disk level, e.g. RAID.
            # List these as well if they haven't already been listed.
            for partition_pair in $partitions; do
              partition_id="${partition_pair#*:}"
              if [ "${partition_id#*-part}" = "$partition_id" ]; then
                case ", $ids, " in
                  ", $partition_id, ") ;;
                  *)
                    ids="${ids:+$ids, }$partition_id"
                    describe_disk "$(readlink -f "$partition_id")" "$partition_id"
                    RET="$(printf %s "$RET" | sed 's/,/\\,/g')"
                    descriptions="${descriptions:+$descriptions, }$RET"
                    ;;
                esac
              fi
            done
            db_subst "$question" RAW_CHOICES "$ids"
            db_subst "$question" CHOICES "$descriptions"
            db_input high "$question" || true
            db_go
            db_get "$question"
            failed_devices=
            for i in `echo $RET | sed -e 's/, / /g'` ; do
              real_device="$(readlink -f "$i")"
              if grub-install --force --no-floppy $real_device ; then
                # We just installed GRUB 2; then also generate grub.cfg.
                touch /boot/grub/grub.cfg
              else
                failed_devices="$failed_devices $real_device"
              fi
            done

            if [ "$question" != grub-pc/install_devices ]; then
              db_set grub-pc/install_devices "$RET"
              db_fset grub-pc/install_devices seen true
            fi

            if [ "$failed_devices" ]; then
              if [ "$UPGRADE_FROM_GRUB_LEGACY" ]; then
                db_subst grub-pc/install_devices_failed_upgrade FAILED_DEVICES "$failed_devices"
                db_fset grub-pc/install_devices_failed_upgrade seen false
                if db_input critical grub-pc/install_devices_failed_upgrade; then
                  db_go
                  db_get grub-pc/install_devices_failed_upgrade
                  if [ "$RET" = true ]; then
                    db_fset "$question" seen false
                    db_fset grub-pc/install_devices_failed_upgrade seen false
                    continue
                  else
                    exit 1
                  fi
                else
                  exit 1 # noninteractive
                fi
              else
                db_subst grub-pc/install_devices_failed FAILED_DEVICES "$failed_devices"
                db_fset grub-pc/install_devices_failed seen false
                if db_input critical grub-pc/install_devices_failed; then
                  db_go
                  db_get grub-pc/install_devices_failed
                  if [ "$RET" = true ]; then
                    break
                  else
                    db_fset "$question" seen false
                    db_fset grub-pc/install_devices_failed seen false
                    continue
                  fi
                else
                  break # noninteractive
                fi
              fi
            fi

            db_get grub-pc/install_devices
            if [ -z "$RET" ]; then
              # Reset the seen flag if the current answer is false, since
              # otherwise we'll loop with no indication of why.
              db_get grub-pc/install_devices_empty
              if [ "$RET" = false ]; then
                db_fset grub-pc/install_devices_empty seen false
              fi
              if db_input critical grub-pc/install_devices_empty; then
                db_go
                db_get grub-pc/install_devices_empty
                if [ "$RET" = true ]; then
                  break
                else
                  db_fset "$question" seen false
                  db_fset grub-pc/install_devices_empty seen false
                fi
              else
                break # noninteractive
              fi
            else
              break
            fi
          done
        fi

        # /boot/grub/ has more chances of being accessible by GRUB
        if test -e /boot/grub/grub.cfg ; then
          for i in /usr/share/grub/unicode.pf2 ; do
            if test -e $i ; then
              cp $i /boot/grub/
            fi
          done
        fi

        if [ "$fix_mixed_system" ]; then
          # These never contain any valuable information, and they aren't
          # useful for boot any more, since we just overwrote MBR/PBR.
          rm -f /boot/grub/{{xfs,reiserfs,e2fs,fat,jfs,minix}_stage1_5,stage{1,2}}
          # Remove marker file used to indicate that grub-install was run
          # rather than upgrade-from-grub-legacy.  Since stage2 has been
          # removed, we don't need this any more.
          rm -f /boot/grub/grub2-installed
        fi
      ;;

      grub-efi-ia32|grub-efi-amd64)
        bootloader_id="$(config_item GRUB_DISTRIBUTOR | tr A-Z a-z | \
                         cut -d' ' -f1)"
        if [ "$bootloader_id" ] && [ -d "/boot/efi/EFI/$bootloader_id" ]; then
          grub-install
        fi
      ;;

      grub-yeeloong)
        grub-install
      ;;
    esac

    # If grub.cfg has been generated, update it.
    if test -e /boot/grub/grub.cfg ; then
      update-grub 3>&-
    fi
  ;;
  abort-upgrade|abort-remove|abort-deconfigure)
  ;;
  *)
    echo "postinst called with unknown argument \`$1'" >&2
    exit 1
  ;;
esac

# dh_installdeb will replace this with shell code automatically
# generated by other debhelper scripts.



exit 0