Have kayak install full-GPT disks and use BSD Loader

          --- old/disk_help.sh
          +++ new/disk_help.sh

   1    1  #!/usr/bin/bash
   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, Version 1.0 only
   7    7  # (the "License").  You may not use this file except in compliance
   8    8  # with the License.
   9    9  #
  10   10  # You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  11   11  # or http://www.opensolaris.org/os/licensing.
  12   12  # See the License for the specific language governing permissions
  13   13  # and limitations under the License.
  14   14  #
  15   15  # When distributing Covered Code, include this CDDL HEADER in each
  16   16  # file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  17   17  # If applicable, add the following below this CDDL HEADER, with the
  18   18  # fields enclosed by brackets "[]" replaced with your own identifying
  19   19  # information: Portions Copyright [yyyy] [name of copyright owner]
  20   20  #
  21   21  # CDDL HEADER END
  22   22  #
  23   23  #
  24   24  # Copyright 2012 OmniTI Computer Consulting, Inc.  All rights reserved.
  25   25  # Use is subject to license terms.
  26   26  #
  27   27  ListDisks() {
  28   28    declare -A disksize
  29   29    declare -A diskname
  30   30    for rdsk in $(prtconf -v | grep dev_link | awk -F= '/\/dev\/rdsk\/c.*p0/{print $2;}')
  31   31    do
  32   32      disk=`echo $rdsk | sed -e 's/.*\///g; s/p0//;'`
  33   33      size=`prtvtoc $rdsk 2>/dev/null | awk '/bytes\/sector/{bps=$2} /sectors\/cylinder/{bpc=bps*$2} /accessible sectors/{print ($2*bps)/1048576;} /accessible cylinders/{print int(($2*bpc)/1048576);}'`
  34   34      disksize+=([$disk]=$size)
  35   35    done
  36   36  
  37   37    disk=""
  38   38    while builtin read diskline
  39   39    do
  40   40      if [[ -n "$disk" ]]; then
  41   41        desc=`echo $diskline | sed -e 's/^[^\<]*//; s/[\<\>]//g;'`
  42   42        diskname+=([$disk]=$desc)
  43   43        disk=""
  44   44      else
  45   45        disk=$diskline
  46   46      fi
  47   47    done < <(format < /dev/null | awk '/^ *[0-9]*\. /{print $2; print;}')
  48   48  
  49   49    for want in $*
  50   50    do
  51   51      for disk in "${!disksize[@]}" ; do
  52   52        case "$want" in
  53   53          \>*)
  54   54              if [[ -n ${disksize[$disk]} && "${disksize[$disk]}" -ge "${want:1}" ]]; then
  55   55                echo $disk
  56   56              fi
  57   57            ;;
  58   58          \<*)
  59   59              if [[ -n ${disksize[$disk]} && "${disksize[$disk]}" -le "${want:1}" ]]; then
  60   60                echo $disk
  61   61              fi
  62   62            ;;
  63   63          *)
  64   64            if [[ "$disk" == "$want" ]]; then
  65   65              echo $disk
  66   66            fi
  67   67            ;;
  68   68        esac
  69   69      done
  70   70  
  71   71      for disk in "${!diskname[@]}" ; do
  72   72        case "$want" in
  73   73          ~*)
  74   74            PAT=${want:1}
  75   75            if [[ -n $(echo ${diskname[$disk]} | egrep -e "$PAT") ]]; then
  76   76              echo $disk
  77   77            fi
  78   78            ;;
  79   79        esac
  80   80      done
  81   81    done
  82   82  }
  83   83  ListDisksAnd() {

  84   84    EXPECT=$(( $(echo "$1" | sed -e 's/[^,]//g;' | wc -c) + 0))
  85   85    for part in $(echo "$1" | sed -e 's/,/ /g;'); do
  86   86      ListDisks $part
  87   87    done | sort | uniq -c | awk '{if($1=='$EXPECT'){print $2;}}'
  88   88  }
  89   89  ListDisksUnique(){
  90   90    for term in $*; do
  91   91      ListDisksAnd $term
  92   92    done | sort | uniq | xargs
  93   93  }
  94      -SMIboot() {
  95      -  DISK=$1
  96      -  RDSK=/dev/rdsk/${DISK}p0
  97      -  S2=/dev/rdsk/${DISK}s2
  98      -  fdisk -B ${RDSK}
  99      -  disks -C
 100      -  prtvtoc -h ${RDSK} | awk '/./{p=0;} {if($1=="2"){size=$5;p=1;} if($1=="8"){start=$5;p=1;} if(p==1){print $1" "$2" "$3" "$4" "$5;}} END{size=size-start; print "0 2 00 "start" "size;}' | sort -n | fmthard -s /dev/stdin $S2
 101      -  disks -C
 102      -}
 103   94  
 104   95  BuildRpool() {
 105   96    ztype=""
 106   97    ztgt=""
 107   98    disks=`ListDisksUnique $*`
 108   99    log "Disks being used for rpool: $disks"
 109  100    if [[ -z "$disks" ]]; then
 110  101      bomb "No matching disks found to build rpool"
 111  102    fi
      103 +  rm -f /tmp/kayak-disk-list
 112  104    for i in $disks
 113  105    do
 114      -    SMIboot $i
 115  106      if [[ -n "$ztgt" ]]; then
 116  107        ztype="mirror"
 117  108      fi
 118      -    ztgt="$ztgt ${i}s0"
 119      -    INSTALL_GRUB_TGT="$INSTALL_GRUB_TGT /dev/rsdk/${i}s2"
      109 +    ztgt="$ztgt ${i}"
      110 +    # Keep track of disks for later...
      111 +    echo ${i} >> /tmp/kayak-disk-list
 120  112    done
 121  113    log "zpool destroy rpool (just in case we've been run twice)"
 122  114    zpool destroy rpool 2> /dev/null
 123  115    log "Creating rpool with: zpool create -f rpool $ztype $ztgt"
      116 +  # Just let "zpool create" do its thing. We want GPT disks now.
 124  117    zpool create -f rpool $ztype $ztgt || bomb "Failed to create rpool"
 125  118    BuildBE
 126  119  }
 127  120  GetTargetVolSize() {
 128  121      # Aim for 25% of physical memory (minimum 1G)
 129  122      # prtconf always reports in megabytes
 130  123      local mem=`/usr/sbin/prtconf | /bin/awk '/^Memory size/ { print $3 }'`
 131  124      if [[ $mem -lt 4096 ]]; then
 132  125          local vsize=1
 133  126      else

 134  127          local quart=`echo "scale=1;$mem/4096" | /bin/bc`
 135  128          local vsize=`printf %0.f $quart`
 136  129      fi
 137  130      echo $vsize
 138  131  }    
 139  132  GetRpoolFree() {
 140  133      local zfsavail=`/sbin/zfs list -H -o avail rpool`
 141  134      if [[ ${zfsavail:(-1)} = "G" ]]; then
 142  135          local avail=`printf %0.f ${zfsavail::-1}`
 143  136      elif [[ ${zfsavail:(-1)} = "T" ]]; then
 144  137          local gigs=`echo "scale=1;${zfsavail::-1}*1024" | /bin/bc`
 145  138          avail=`printf %0.f $gigs`
 146  139      else
 147  140          # If we get here, there's too little space left to be usable
 148  141          avail=0
 149  142      fi
 150  143      echo $avail
 151  144  }
 152  145  MakeSwapDump() {
 153  146      local size=`GetTargetVolSize`
 154  147      local totalvols=""
 155  148      local usable=""
 156  149      local finalsize=""
 157  150      local savecore=""
 158  151  
 159  152      # We're creating both swap and dump volumes of the same size
 160  153      let totalvols=${size}*2
 161  154  
 162  155      # We want at least 10GB left free after swap/dump
 163  156      # If we can't make swap/dump at least 1G each, don't bother
 164  157      let usable=`GetRpoolFree`-10
 165  158      if [[ $usable -lt 2 ]]; then
 166  159          log "Not enough free space for reasonably-sized swap and dump; not creating either."
 167  160          return 0
 168  161      fi
 169  162  
 170  163      # If the total of swap and dump is greater than the usable free space,
 171  164      # make swap and dump each take half but don't enable savecore
 172  165      if [[ $totalvols -ge $usable ]]; then
 173  166          let finalsize=${usable}/2
 174  167          savecore="-n"
 175  168      else
 176  169          finalsize=$size
 177  170          savecore="-y"
 178  171      fi
 179  172  
 180  173      for volname in swap dump; do
 181  174          /sbin/zfs create -V ${finalsize}G rpool/$volname || \
 182  175              bomb "Failed to create rpool/$volname"
 183  176      done
 184  177      printf "/dev/zvol/dsk/rpool/swap\t-\t-\tswap\t-\tno\t-\n" >> $ALTROOT/etc/vfstab
 185  178      Postboot /usr/sbin/dumpadm $savecore -d /dev/zvol/dsk/rpool/dump
 186  179      return 0
 187  180  }

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX