xcat-core/xCAT-SoftLayer/bin/modifygrub

#!/usr/bin/perl

# Modify the grub config file on the node to boot the specified kernel and initrd.
# This script is meant to be run on the node via xdsh -e.
# Currently requires that dns on the mn be configured and working to resolve the short node names.

use strict;
use Getopt::Long;
use Data::Dumper;
use Socket;

# Globals - these are set once and then only read.
my $HELP;
my $VERBOSE;
my $DRYRUN;
my $WAITTIME;
my $PROVMETHOD;
my $XCATNETBOOTTITLE = 'xCAT network boot kernel and initrd';

my $usage = sub {
    my $exitcode = shift @_;
    print "Usage: modifygrub [-?|-h|--help] [-v|--verbose] [--dryrun] [-w <waittime>] [-p <provmethod] <kernel-path> <initrd-path> <kernel-parms> <mn-ip>\n\n";
    if (!$exitcode) {
        print "Modify the grub config file on the node to boot the specified kernel and initrd.\n";
    }
    exit $exitcode;
};


my $file = '/etc/os-release';
if (-f $file) {
    #
    # SLES and RHEL also have /etc/os-release file, so actually need to open the file
    # and look for Ubuntu in the 'NAME=' lines before declaring Ubuntu
    #
    open my $info, $file or die "Could not open $file: $!";
    while (my $line = <$info>) {
        if (index($line, 'NAME=') != -1) {
            if ($line =~ /Ubuntu/i) {
                die "This script does not support Ubuntu at this time.\n";
            }
        }
    }
    close $info;
}

# Process the cmd line args
Getopt::Long::Configure("bundling");

#Getopt::Long::Configure("pass_through");
Getopt::Long::Configure("no_pass_through");
if (!GetOptions('h|?|help' => \$HELP, 'v|verbose' => \$VERBOSE, 'dryrun' => \$DRYRUN, 'w|waittime=s' => \$WAITTIME, 'p|provmethod=s' => \$PROVMETHOD)) { $usage->(1); }

if ($HELP) { $usage->(0); }
if (scalar(@ARGV) != 4) { $usage->(1); }
if (!defined($WAITTIME)) { $WAITTIME = 60; } # seconds to wait after configuring the nic (to let the switch handle the state change)
my %args;
$args{kernelpath}  = $ARGV[0];
$args{initrdpath}  = $ARGV[1];
$args{kernelparms} = $ARGV[2];
$args{mnip}        = $ARGV[3];

addKernelParms(\%args);    # replace and add some parms to args{kernelparms}
updateGrub(\%args); # update the grub config with an entry filled with the info in args

exit(0);


# Add ip and net info to the kernel parms.  Modifies the kernelparms value of the args hash passed in.
sub addKernelParms {
    my $args = shift @_;

    # replace '!myipfn!' with the mn ip
    my $mnip = $args->{mnip};
    $args->{kernelparms} =~ s/!myipfn!/$mnip/g;

    # replace <nodename> with the nodename
    my $nodename = $ENV{NODE};    # this env var is set by xdsh
    $args->{kernelparms} =~ s/<nodename>/$nodename/g;

    # get node ip and add it to the kernel parms
    my ($nic, $ip, $netmask, $network, $broadcast, $gateway, $mac) = getNodeIpInfo($args);
    if (!$ip) { die "Error: could not find the NIC that would connect to the xCAT mgmt node's IP (" . $args->{mnip} . ").\n"; }

    #if (defined($PROVMETHOD) && $PROVMETHOD eq 'sysclone') {
    if ($args->{kernelpath} =~ m/genesis\.kernel\.x86_64/) {

        # genesis case, add additional parms for sysclone or nodeset shell
        my $bootif = $mac;
        $bootif =~ s/:/-/g;
        $bootif = "BOOTIF=01-$bootif";

        # DEVICE=eth0 IPADDR=10.0.0.99 NETMASK=255.255.255.0 NETWORK=10.0.0.0 BROADCAST=10.0.0.255 GATEWAY=10.0.0.1 GATEWAYDEV=eth0
        #todo:  should we also add ETHER_SLEEP=$WAITTIME textmode=1 dns=$mnip ?
        $args->{kernelparms} .= " $bootif IPADDR=$ip NETMASK=$netmask NETWORK=$network BROADCAST=$broadcast GATEWAY=$gateway HOSTNAME=$nodename DEVICE=$nic GATEWAYDEV=$nic";
    }
    else {    # scripted install (kickstart or autoyast)
        if ($args->{kernelparms} =~ m/autoyast=/) {    # sles
             # if site.managedaddressmode=static is set, it will put several of these kernel parms on there for us.  Do not duplicate in that case.
            if ($args->{kernelparms} !~ m/ hostip=/) { $args->{kernelparms} .= " hostip=$ip"; }
            if ($args->{kernelparms} !~ m/ netmask=/) { $args->{kernelparms} .= " netmask=$netmask"; }
            if ($args->{kernelparms} !~ m/ gateway=/) { $args->{kernelparms} .= " gateway=$gateway"; }
            if ($args->{kernelparms} !~ m/ hostname=/) { $args->{kernelparms} .= " hostname=$nodename"; }
            if ($args->{kernelparms} !~ m/ dns=/) { $args->{kernelparms} .= " dns=$mnip"; }

            # If they set installnic=mac (recommended), the netdevice will already be set to the mac.
            # If they explicitly set installnic=<nic>, then ksdevice will be set to that and we will not disturb it here.
            # Otherwise add netdevice set to the nic we calculated it should be.
            if ($args->{kernelparms} !~ m/ netdevice=/) { $args->{kernelparms} .= " netdevice=$nic"; }
            $args->{kernelparms} .= " netwait=$WAITTIME textmode=1";

            # print Dumper($args->{kernelparms})
        }
        elsif ($args->{kernelparms} =~ m/ks=/) {    # rhel/centos
             # See https://www.centos.org/docs/5/html/Installation_Guide-en-US/s1-kickstart2-startinginstall.html
             # and  http://fedoraproject.org/wiki/Anaconda/NetworkIssues for description of kickstart kernel parms
             # if site.managedaddressmode=static is set, it will put several of these kernel parms on there for us.  Do not duplicate in that case.
            if ($args->{kernelparms} !~ m/ ip=/) { $args->{kernelparms} .= " ip=$ip"; }
            if ($args->{kernelparms} !~ m/ netmask=/) { $args->{kernelparms} .= " netmask=$netmask"; }
            if ($args->{kernelparms} !~ m/ gateway=/) { $args->{kernelparms} .= " gateway=$gateway"; }
            if ($args->{kernelparms} !~ m/ hostname=/) { $args->{kernelparms} .= " hostname=$nodename"; }
            if ($args->{kernelparms} !~ m/ dns=/) { $args->{kernelparms} .= " dns=$mnip"; }

            # If they set installnic=mac (recommended), the ksdevice will already be set to the mac.
            # If they explicitly set installnic=<nic>, then ksdevice will be set to that and we will not disturb it here.
            # Otherwise ksdevice will be set to bootif, and we change it to the nic we calculated it should be.
            if ($args->{kernelparms} =~ m/ ksdevice=bootif/) { $args->{kernelparms} =~ s/ ksdevice=bootif/ ksdevice=$nic/; }
            elsif ($args->{kernelparms} !~ m/ ksdevice=/) { $args->{kernelparms} .= " ksdevice=$nic"; }
            $args->{kernelparms} .= " nicdelay=$WAITTIME linksleep=$WAITTIME textmode=1";

            # print Dumper($args->{kernelparms})
        }
        else { die "Error: for scripted installs, only support SLES or RHEL/CentOS as the target OS.\n"; }
    }
}


# get this nodes nic, ip, netmask, gateway, and mac.  Returns them in a 5 element array.
sub getNodeIpInfo {
    my $args = shift @_;
    my ($ipprefix) = $args->{mnip} =~ m/^(\d+)\./; #todo: this is a hack, just using the 1st octet of the mn ip addr
    verbose("using IP prefix $ipprefix");

    # parse ip addr show output, looking for ipprefix, to determine nic, ip, mac
    my @output = runcmd("/sbin/ip addr show");
    my ($nic, $mac, $ipandmask);
    foreach my $line (@output) {
        my ($nictmp, $mactmp, $iptmp);
        if (($nictmp) = $line =~ m/^\d+:\s+(\S+): /) { $nic = $nictmp; } # new stanza, remember it
        if (($mactmp) = $line =~ m|^\s+link/ether\s+(\S+) |) { $mac = $mactmp; } # got mac, remember it
        if (($iptmp) = $line =~ m/^\s+inet\s+($ipprefix\S+) /) { $ipandmask = $iptmp; last; } # got ip, we are done
    }
    if (!defined($ipandmask)) { die "Error: can't find a NIC with a prefix $ipprefix that communicates with" . $args->{mnip} . ".\n"; }
    my ($ip, $netmask, $network, $broadcast) = convertIpAndMask($ipandmask);

    # if the nic is a bonded nic (common on sl), then find the 1st real nic that is up that is part of it.
    # also find that real nics real mac
    my $realnic;
    if ($nic =~ /^bond/) {
        my @nics = grep(m/\s+master\s+$nic\s+/, @output);
        if (!scalar(@nics)) { die "Error: can't find the NICs that are part of $nic.\n"; }
        foreach my $line (@nics) {
            my ($nictmp, $state) = $line =~ m/^\d+:\s+(\S+): .* state\s+(\S+)/;
            if (defined($nictmp) && defined($state) && $state eq 'UP') { $realnic = $nictmp; last; } # got ip, we are done
        }
        if (!defined($realnic)) { die "Error: can't find a physical NIC that is up and part of $nic.\n"; }

        # now get the real mac of this real nic (when 2 nics are bonded, ip addr show displays one of the nics
        # macs for both nics and the bond).  So we have to depend on /proc/net/bonding/$bond instead.
        my @bondout = runcmd("cat /proc/net/bonding/$nic");
        my $foundnic;
        foreach my $line (@bondout) {
            my $mactmp;
            if ($line =~ m/^Slave Interface:\s+$realnic/) { $foundnic = 1; } # found the stanza for this nic, remember it
            if ($foundnic && (($mactmp) = $line =~ m/^Permanent HW addr:\s+(\S+)/)) { $mac = $mactmp; last; }
        }
    }
    else { $realnic = $nic; }

    # centos/redhat seems to name the nic in a different order than sles on some svrs.
    # sles seems to name them in the same order as 'ip addr show' displays them, centos does not.
    # so if we are on centos right now, we need to count down to determine the number that sles
    # will give the nic that we have selected, because it is the sles naming that we care about,
    # because that is the initrd that will be running in the scripted install case.
    # This works similarly (at least in some case) when rhel is the target OS.
    # The preferred way is for the user to set installnic=mac, then we do not need to run this code.
    # For the sysclone case, genesis doxcat uses the mac to find the nic.
    if (isRedhat() && $args->{kernelparms} !~ m/ ksdevice=\S*:/ && $args->{kernelparms} !~ m/ netdevice=\S*:/) {
        my @nics = grep(m/^\d+:\s+eth/, @output);
        my $i = 0;
        foreach my $line (@nics) {
            my ($nictmp) = $line =~ m/^\d+:\s+(\S+):/;
            if (defined($nictmp) && $nictmp eq $realnic) { $realnic = "eth$i"; last; } # got ip, we are done
            $i++;
        }
        print "Determined that SLES/RHEL will call the install NIC $realnic (it has mac $mac)\n";
    }

    # finally, find the gateway
    my $gateway;
    my @output = runcmd("/sbin/ip route");

    # we are looking for a line like: 10.0.0.0/8 via 10.54.51.1 dev bond0
    my @networks = grep(m/ via .* $nic\s*$/, @output);
    if (scalar(@networks)) { ($gateway) = $networks[0] =~ m/ via\s+(\S+)/; }
    else {
        # use the mn ip as a fall back
        $gateway = $args->{mnip};
        verbose("using xCAT mgmt node IP as the fall back gateway.");
    }

    verbose("IP info: realnic=$realnic, ip=$ip, netmask=$netmask, gateway=$gateway, mac=$mac");
    return ($realnic, $ip, $netmask, $network, $broadcast, $gateway, $mac);
}


# Convert an ip/mask in slash notation (like 10.1.1.1/26) to separate ip, netmask, network, and broadcast values,
# like: 10.1.1.1, 255.255.255.192, 10.1.1.0, 10.1.1.63
sub convertIpAndMask {
    my $ipandmask = shift @_;
    my ($ip, $masknum) = split('/', $ipandmask);

    # build the netmask
    my $nmbin = oct("0b" . '1' x $masknum . '0' x (32 - $masknum)); # create a str like '1111100', then convert to binary
    my @nmarr = unpack('C4', pack('N', $nmbin));    # separate into the 4 octets
    my $netmask = join('.', @nmarr); # put them together into the normal looking netmask

    # create binary form of ip
    my @iparr = split(/\./, $ip);
    my ($ipbin) = unpack('N', pack('C4', @iparr));

    # Calculate network address by logical AND operation of ip & netmask and convert network address to IP address format
    my $netbin  = ($ipbin & $nmbin);
    my @netarr  = unpack('C4', pack('N', $netbin));
    my $network = join(".", @netarr);

    # Calculate broadcast address by inverting the netmask and adding it to the network address
    my $bcbin = ($ipbin & $nmbin) + (~$nmbin);
    my @bcarr = unpack('C4', pack('N', $bcbin));
    my $broadcast = join(".", @bcarr);

    return ($ip, $netmask, $network, $broadcast);
}


# not used - resolve the hostname to an ip addr
sub getipaddr {
    my $hostname = shift @_;
    my $packed_ip;
    $packed_ip = inet_aton($hostname);
    if (!$packed_ip) { return undef; }
    return inet_ntoa($packed_ip);
}


# Update the grub config file with a new stanza for booting our kernel and initrd
sub updateGrub {
    my $args = shift @_;

    # how we specify the path for the kernel and initrd is different on redhat and suse
    my $fileprefix;
    if    (isRedhat()) { $fileprefix = '/'; }
    elsif (isSuse())   { $fileprefix = '/boot/'; }
    else { die "Error: currently only support red hat or suse distros.\n"; }

    # open the grub file and see if it is in there or if we have to add it
    my $grubfile = findGrubPath();
    verbose("reading $grubfile");
    open(FILE, $grubfile) || die "Error: can not open config file $grubfile for reading: $!\n";
    my @lines = <FILE>;
    close FILE;

    # this is the entry we want in the grub file
    my @rootlines = grep(/^\s+root\s+/, @lines); # copy one of the existing root lines
    if (!scalar(@rootlines)) { die "Error: can't find an existing line for 'root' in the grub config file\n"; }
    my ($rootline) = $rootlines[0] =~ m/^\s*(.*?)\s*$/;
    my @entry = (
        "title $XCATNETBOOTTITLE\n",
        "\t$rootline\n",
"\tkernel " . $fileprefix . $args->{kernelpath} . ' ' . $args->{kernelparms} . "\n",
        "\tinitrd " . $fileprefix . $args->{initrdpath} . "\n",
    );
    if ($DRYRUN) {
        print "Dry run:  would add this stanza to $grubfile:\n";
        foreach my $l (@entry) { print $l; }
        return;
    }

    my $needtowritefile = 1;
    if (grep(/^title\s+$XCATNETBOOTTITLE/, @lines)) { $needtowritefile = updateGrubEntry(\@lines, \@entry); } # there is already an entry in there
    else { addGrubEntry(\@lines, \@entry); }

    # write the file with the new/updated xcat entry
    if ($needtowritefile) {
        verbose("updating $grubfile");
        open(FILE, '>', $grubfile) || die "Error: can not open config file $grubfile for writing: $!\n";
        print FILE @lines;
        close FILE;
    }
    else { print "Info: $grubfile did not need modifying. It was already up to date.\n"; }
}


# add our entry as the 1st one in the grub file
sub addGrubEntry {
    my ($lines, $entry) = @_;

    # find the index of the 1st stanza (it starts with 'title')
    my $i;
    for ($i = 0 ; $i < scalar(@$lines) ; $i++) {
        if ($lines->[$i] =~ m/^title\s+/) { verbose('adding xcat entry before:' . $lines->[$i]); last; } # found it
    }

    # splice the entry right before the i-th line (which may also be 1 past the end)
    splice(@$lines, $i, 0, @$entry);
}


# check the xcat entry in the grub file and see if it needs to be updated.  Return 1 if it does.
sub updateGrubEntry {
    my ($lines, $entry) = @_;

    #print Dumper($lines), Dumper($entry);
    # find the index of the xcat stanza
    my $i;
    for ($i = 0 ; $i < scalar(@$lines) ; $i++) {
        if ($lines->[$i] =~ m/^title\s+$XCATNETBOOTTITLE/) { last; }  # found it
    }

    # compare the next few lines with the corresponding line in @$entries and replace if different
    my $replaced = 0;
    for (my $j = 0 ; $j < scalar(@$entry) ; $j++) {

        #print "comparing:\n  ", $lines->[$i+$j], "\n  ", $entry->[$j], "\n";
        if ($lines->[ $i + $j ] ne $entry->[$j]) {    # this line was different
            $lines->[ $i + $j ] = $entry->[$j];
            $replaced = 1;
        }
    }

    return $replaced;
}


# depending on the distro, find the correct grub file and return its path
sub findGrubPath {

    # for rhel/centos it is /boot/grub/grub.conf, for sles it is /boot/grub/menu.lst
    my @paths = qw(/boot/grub/grub.conf /boot/grub/menu.lst);
    foreach my $p (@paths) {
        if (-f $p) { return $p; }
    }

    die "Error: Can't find grub config file.\n";

    #todo: support ubuntu: you add an executable file in /etc/grub.d named 06_xcatnetboot that prints out the
    #		entry to add.  Then run grub-mkconfig.
}


# Pring msg only if -v was specified
sub verbose { if ($VERBOSE) { print shift, "\n"; } }

# Check the distro we are running on
sub isSuse { return (-e '/etc/SuSE-release'); }
sub isRedhat { return (-e '/etc/redhat-release' || -e '/etc/centos-release' || -e '/etc/fedora-release'); } # add chk for fedora



# Run a command.  If called in the context of return an array, it will capture the output
# of the cmd and return it.  Otherwise, it will display the output to stdout.
# If the cmd has a non-zero rc, this function will die with a msg.
sub runcmd
{
    my ($cmd) = @_;
    my $rc;

    $cmd .= ' 2>&1';
    verbose($cmd);

    my @output;
    if (wantarray) {
        @output = `$cmd`;
        $rc     = $?;
    }
    else {
        system($cmd);
        $rc = $?;
    }

    if ($rc) {
        $rc = $rc >> 8;
        if   ($rc > 0) { die "Error: rc $rc return from cmd: $cmd\n"; }
        else           { die "Error: system error returned from cmd: $cmd\n"; }
    }
    elsif (wantarray) { return @output; }
}