[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]

Re: Automated Partitioning



Hi David,

I've attached the preliminary version of my script, which will give you an idea about what I'm trying to do. (by no means is this touted to be well-written!) I discovered that there's overflow errors with calculations on disk sizes > 40G or so, but this could be fixed by doing calculation in Megabytes, as opposed to 1k blocks like I am/was.

Anyways, the problem with this is that by the time this script has been executed, anaconda has already read in the entire config script, and hence already has it's partitioning information. My goal is to have the script use 'sed' to shove in the new partition values, and then have anaconda re-start itself ( hoping that it won't try and re-fetch the config script from the server).

anyhow, here's the way things are curently set up for this script: a directory on the kickstart server has my script, and the expr and sfdisk binaries (and a link to device node that I make)

[erik kickstart partition]$ ls -al
total 80
drwxr-xr-x 2 root daemon 4096 Mar 10 17:07 ./
drwxr-xr-x 6 root daemon 4096 Mar 10 00:37 ../
-rwxr-xr-x 1 root daemon 6115 Mar 10 13:44 disk-setup*
-rwxr-xr-x 1 root daemon 12908 Mar 9 19:23 expr*
lrwxrwxrwx 1 root daemon 6 Mar 9 19:56 hda -> ../hda
-rwxr-xr-x 1 root daemon 46780 Mar 9 19:23 sfdisk*


and here's the %pre section from my kickstart config:


%pre
mkdir /tmp/pre-install; mkdir /tmp/pre-install/mnt
cd /tmp/pre-install
# make device node for hda - for use by sfdisk to determine disk size
mknod hda
mount kickstart:/exports/custom/partition /tmp/pre-install/mnt
cd mnt
# Have to add the current dir so that expr and sfdisk will work.
export PATH=$PATH:.
sh ./disk-setup -t server > /tmp/disk-results

I'm spending the next few days getting cozy with python, going to see if there's a better way!
Enjoy,
Erik.


PS - I hink that the switch that you're looking for is :

--grow
Tells the partition to grow to fill available space (if any), or up to maximum size setting. (from the redhat reference guide - http://www.redhat.com/support/manuals/RHL-7-Manual/ref-guide/s1-kickstart2-commands.html)


David T-G wrote:

Hi, all --

...and then Taylor, ForrestX said...
% ...
% # partitions
% zerombr yes
% #clearpart --all
% clearpart --linux
% part swap --size 512
% part /boot --size 512
% part /home --size 3000
% part /multimedia --size 5000
% part / --size 5000 --grow


I have a somewhat related question...  I'd like to specify certain
partitions (root, var, swap) and then have one more that uses whatever is
left.  [Actually, I think it would be great to have Erik's script that
parses disk size and decideds based on that, since I come from a Sun
JumpStart environment and find kickstart, cool though it may be, somewhat
limiting.]  I have't found the switch for "free" or "freehog" or "the
rest" or whatever.  Is there one?

Speaking of which, I now recall a second question.  I'd like for my
partition table to lay out as

  sda1   -  swap
  sda2   -  root
  sda3   -  var
  sda4   -  extended partition containing
    sda5 -  /drv1 (my "the rest" slice)

but I seem to always end up with swap down in the middle of the disk
somewhere and more extended partitions than I expect.  Can I be more
specific in my layout?


TIA (twice) & HAND


:-D



#!/bin/bash

usage() {
    echo "Usage:" $0 "-t ['workstation'/'server'] -s <disk size> -u ['M'/'K']"
    echo "     -t - type of build"
    echo "     -s - size of disk.  If not specified, is fetched from the os."
    echo "     -u - units.  either (M)egabytes or (K)ilobytes."
    exit 1
}

echo

# If more than 6 arguments, or less than 2, something's definitely wrong.
if [ $# -gt 6 -o $# -lt 2 ]; then
    usage
fi 

while getopts s:t:u: opt
do
    case $opt in
	s) DISK_SIZE=$OPTARG
	   #let "DISK_SIZE = $OPTARG * 1024"
	   ;;
        t) OARG=$OPTARG
	    case $OARG in
		workstation|WORKSTATION) 
		    SCHEME="workstation";;
		server|SERVER) 
		    SCHEME="server";;
		*) usage;;    
	    esac
	    ;;
	u) case $OPTARG in
	    b|k|B|K)
		UNITS="Blocks"
		;;
	    m|M)
		UNITS="Mb"
		;;
	    *)usage
	    ;;
	   esac
	   ;;
	*) usage
           ;;    
    esac
done

shift `expr $OPTIND - 1`

# Default (minimum) values, assuming a 4G disk.
MIN_DISK_SIZE=4194304 # 4096M * 1024
ROOT_SIZE=524288      # 512M  * 1024
MIN_USR=1835008       # 1792M * 1024
MAX_USR=7340032       # 7168M * 1024
MIN_VAR=786432        # 768M  * 1024
MIN_TMP=524288        # 512M  * 1024
MIN_SWAP=524288       # 512M  * 1024
MAX_SWAP=0            # 3x Physical memory 
SWAP_LIMIT=2096128    # 2047M * 1024 - Swap partition can't be bigger'n this

# If unspecified, units are 1k-blocks.
if [ -z $UNITS ]; then
    UNITS="Blocks"
fi

# If the size wasn't specified, go fetch it.
if [ -z $DISK_SIZE ]; then
    if [ -b ./hda ]; then
	# system in installation
	DISK_SIZE=`sfdisk -s ./hda`
    elif [ -b /dev/hda ]; then
	# production system
	DISK_SIZE=`sfdisk -s /dev/hda`
    else
	echo "I Couldn't find any info on the first hard disk."
	exit 1
    fi
else
    if [ "$UNITS" = "Mb" ]; then
	let "DISK_SIZE = $DISK_SIZE * 1024"
    fi
fi

let "DISK_SIZE_M = $DISK_SIZE / 1024"
echo "Total Disk Size       : "$DISK_SIZE" 1k blocks ("$DISK_SIZE_M"M)"

# Check to make sure this disk isn't too small.
if [ $DISK_SIZE -lt $MIN_DISK_SIZE ]; then
    echo
    echo "This utility has been set up to work with disks that are"
    echo "a minimum of 4G in size.  Sorry."
    echo
    exit 1
fi

# I've shaved off 50 Megs here to account for cylinder boundaries, etc.
# Assuming that kickstart is similar to the normal installer in that 
# It tends to round up partition sizes to make them break on cylinders.
# This will be given back with the '--grow' option.
let "REMAINING_SPACE = $DISK_SIZE - 50000"

# Swap size Calculations - First, find how much memory we've got.
tempArray=(`grep MemTotal /proc/meminfo`)
PHYSICAL_MEM=${tempArray[1]}

# Linux has a swap partition size limit of 2047m.  Since there's the 
# chance that we'll actually make swap = mem * 3, make sure that doesn't 
# break the rule.
let "MAX_SWAP = $PHYSICAL_MEM * 3"
if [ $MAX_SWAP -gt $SWAP_LIMIT ]; then
    let "MAX_SWAP = $SWAP_LIMIT"
fi

echo "Total Physical Memory :" $PHYSICAL_MEM"k"

echo

if [ $SCHEME = "workstation" ]; then
    echo "Workstation-Type Partitioning Scheme"
else
    echo "Server-Type Partitioning Scheme"
fi

# First round.  After / is taken care of, the leftover disk is distributed
# As follows:
# /usr - 50%
# <swap> - 14%
# tmp (workstation) - 21% (server) - 15%
# var (workstation) - 15% (server) - 21%

echo "------------------------------------"
echo
echo "First Round, without constraints:"

let "ROOT = ROOT_SIZE"
let "REMAINING_SPACE = $REMAINING_SPACE - $ROOT"

let "USR = (50 * $REMAINING_SPACE) / 100"
let "SWAP = (14 * $REMAINING_SPACE) / 100"

if [ $SCHEME = "workstation" ]; then
    let "VAR = (15 * $REMAINING_SPACE) / 100"
    let "TMP = (21 * $REMAINING_SPACE) / 100"
else
    let "VAR = (21 * $REMAINING_SPACE) / 100"
    let "TMP = (15 * $REMAINING_SPACE) / 100"
fi

let "REMAINING_SPACE = $REMAINING_SPACE - $USR"
let "REMAINING_SPACE = $REMAINING_SPACE - $SWAP"
let "REMAINING_SPACE = $REMAINING_SPACE - $VAR"
let "REMAINING_SPACE = $REMAINING_SPACE - $TMP"

echo "ROOT = "`expr $ROOT / 1024`
echo "USR  = "`expr $USR / 1024`
echo "SWAP = "`expr $SWAP / 1024`
echo "VAR  = "`expr $VAR / 1024`
echo "TMP  = "`expr $TMP / 1024`

echo "Remaining Space: "`expr $REMAINING_SPACE / 1024`

echo
echo "Checking Contraints..."

if [ $USR -gt $MAX_USR ]; then
    echo "/usr Greater than 7G"
    let "SURPLUS = $USR - $MAX_USR"
    echo "Adding back " `expr $SURPLUS / 1024` " To the pot"
    let "REMAINING_SPACE = $REMAINING_SPACE + $SURPLUS"
    let "USR = $MAX_USR"
fi

if [ $SWAP -gt $MAX_SWAP ]; then
    echo
    echo "<swap> Greater than 3 x PhysicalMem"
    let "SURPLUS = $SWAP - $MAX_SWAP"
    echo "Adding back " `expr $SURPLUS / 1024` " To the pot"
    let "REMAINING_SPACE = $REMAINING_SPACE + $SURPLUS"
    let "SWAP = $MAX_SWAP"
fi

echo
echo "the pot now has" `expr $REMAINING_SPACE / 1024`"m in it."

# Second round.  The leftover disk is distributed as follows:
# tmp (workstation) - 60% (server) - 40%
# var (workstation) - 40% (server) - 60%

if [ $SCHEME = "workstation" ]; then
    let "EXTRA_VAR = (40 * $REMAINING_SPACE) / 100"
    let "EXTRA_TMP = (60 * $REMAINING_SPACE) / 100"
else
    let "EXTRA_VAR = (60 * $REMAINING_SPACE) / 100"
    let "EXTRA_TMP = (40 * $REMAINING_SPACE) / 100"
fi

let "REMAINING_SPACE = $REMAINING_SPACE - $EXTRA_VAR"
let "REMAINING_SPACE = $REMAINING_SPACE - $EXTRA_TMP"

let "VAR = $VAR + $EXTRA_VAR"
let "TMP = $TMP + $EXTRA_TMP"

echo
echo "Here's what I would generate:"
echo "-----------------------------"
    
#echo "ROOT = "`expr $ROOT / 1024`
#echo "USR  = "`expr $USR / 1024`
#echo "SWAP = "`expr $SWAP / 1024`
#echo "VAR  = "`expr $VAR / 1024`
#echo "TMP  = "`expr $TMP / 1024`

let "ROOT = $ROOT / 1024"
let "USR  = $USR / 1024"
let "SWAP = $SWAP / 1024"
let "VAR  = $VAR / 1024"
let "TMP  = $TMP / 1024"

echo "part / --size = "$ROOT
echo "part swap --size = "$SWAP
echo "part /usr --size = "$USR

if [ $SCHEME = "workstation" ]; then
    echo "part /tmp --size = "$TMP "--grow"
    echo "part /var --size = "$VAR
else
    echo "part /tmp --size = "$TMP
    echo "part /var --size = "$VAR "--grow"
fi

echo
echo "Remaining Space: "`expr $REMAINING_SPACE / 1024`


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]