diff --git a/xCAT-server/lib/perl/xCAT/PPC.pm b/xCAT-server/lib/perl/xCAT/PPC.pm
index 8fed4ff76..f0dcaa3f9 100644
--- a/xCAT-server/lib/perl/xCAT/PPC.pm
+++ b/xCAT-server/lib/perl/xCAT/PPC.pm
@@ -59,9 +59,9 @@ sub send_msg {
     my $ecode   = shift;
     my %output;
 
-#################################################
-# Called from child process - send to parent
-#################################################
+    #################################################
+    # Called from child process - send to parent
+    #################################################
     if ( exists( $request->{pipe} )) {
         my $out = $request->{pipe};
 
@@ -70,9 +70,9 @@ sub send_msg {
         print $out freeze( [\%output] );
         print $out "\nENDOFFREEZE6sK4ci\n";
     }
-#################################################
-# Called from parent - invoke callback directly
-#################################################
+    #################################################
+    # Called from parent - invoke callback directly
+    #################################################
     elsif ( exists( $request->{callback} )) {
         my $callback = $request->{callback};
 
@@ -95,18 +95,18 @@ sub process_command {
     my @site     = qw(ppcmaxp ppctimeout maxssh ppcretry fsptimeout); 
     my $start;
 
-#######################################
-# Default site table attributes 
-#######################################
+    #######################################
+    # Default site table attributes 
+    #######################################
     $request->{ppcmaxp}    = 64;
     $request->{ppctimeout} = 0;
     $request->{fsptimeout} = 0;
     $request->{ppcretry}   = 3;
     $request->{maxssh}     = 10;
 
-#######################################
-# Get site table attributes 
-#######################################
+    #######################################
+    # Get site table attributes 
+    #######################################
     if ( defined( $sitetab )) {
         foreach ( @site ) {
             my ($ent) = $sitetab->getAttribs({ key=>$_},'value');
@@ -118,15 +118,15 @@ sub process_command {
     if ( exists( $request->{verbose} )) {
         $start = Time::HiRes::gettimeofday();
     }
-#######################################
-# Group nodes based on command
-#######################################
+    #######################################
+    # Group nodes based on command
+    #######################################
     my $nodes = preprocess_nodes( $request );
     if ( !defined( $nodes )) {
         return(1);
     }
 
-#get new node status
+    #get new node status
     my %oldnodestatus=(); #saves the old node status
         my @allerrornodes=();
     my $check=0;
@@ -147,7 +147,7 @@ sub process_command {
             my $noderange = $request->{node}; 
             my @allnodes=@$noderange;
 
-#save the old status
+            #save the old status
             my $nodelisttab = xCAT::Table->new('nodelist');
             if ($nodelisttab) {
                 my $tabdata     = $nodelisttab->getNodesAttribs(\@allnodes, ['node', 'status']);
@@ -160,16 +160,16 @@ sub process_command {
                     }
                 }
             }
-#print "oldstatus:" . Dumper(\%oldnodestatus);
+            #print "oldstatus:" . Dumper(\%oldnodestatus);
 
-#set the new status to the nodelist.status
+            #set the new status to the nodelist.status
             my %newnodestatus=(); 
             my $newstat;
             if (($subcommand eq 'off') || ($subcommand eq 'softoff')) { 
                 my $newstat=$::STATUS_POWERING_OFF; 
                 $newnodestatus{$newstat}=\@allnodes;
             } else {
-#get the current nodeset stat
+                #get the current nodeset stat
                 if (@allnodes>0) {
                     my $nsh={};
                     my ($ret, $msg)=xCAT::SvrUtils->getNodesetStates(\@allnodes, $nsh);
@@ -183,35 +183,35 @@ sub process_command {
                     }
                 }
             }
-#print "newstatus" . Dumper(\%newnodestatus);
+            #print "newstatus" . Dumper(\%newnodestatus);
             xCAT_monitoring::monitorctrl::setNodeStatusAttributes(\%newnodestatus, 1);
         }
     }
 
 
 
-#######################################
-# Fork process
-#######################################
+    #######################################
+    # Fork process
+    #######################################
     my $children = 0;
     my $fds = new IO::Select;
 
-# For the commands getmacs and rnetboot, each time 
-# to fork process, pick out the HMC that has the 
-# least process number created to connect to the HMC.
-# After the process by preprocess_nodes, the $nodes 
-# variable has following structure:
-# $nodes
-#   |hcp
-#       |[[hcp,node1_attr], [hcp,node2_attr] ...]
-#       |count    //node number managed by the hcp
-#       |runprocess    //the process number connect to the hcp
-#       |index    //the index of node will be forked of the hcp
-    if ( $request->{command} =~ /^(getmacs|rnetboot)$/ ) {
+    # For the commands getmacs and rnetboot, each time 
+    # to fork process, pick out the HMC that has the 
+    # least process number created to connect to the HMC.
+    # After the process by preprocess_nodes, the $nodes 
+    # variable has following structure:
+    # $nodes
+    #   |hcp
+    #       |[[hcp,node1_attr], [hcp,node2_attr] ...]
+    #       |count    //node number managed by the hcp
+    #       |runprocess    //the process number connect to the hcp
+    #       |index    //the index of node will be forked of the hcp
+    if ( ($request->{command} =~ /^(getmacs)$/ && exists( $request->{opt}->{D} )) || ($request->{command} =~ /^(rnetboot)$/) ) {
         my %pid_owner = ();
 
-# Use the CHID signal to control the 
-#connection number of certain hcp    
+        # Use the CHID signal to control the 
+        #connection number of certain hcp    
         $SIG{CHLD} = sub { my $pid = 0; while (($pid = waitpid(-1, WNOHANG)) > 0) 
             { $nodes->{$pid_owner{$pid}}{'runprocess'}--; $children--; } };
 
@@ -221,14 +221,14 @@ sub process_command {
                 my $handlednodes={};
                 child_response( $callback, $fds, $handlednodes);
 
-#update the node status to the nodelist.status table
+                #update the node status to the nodelist.status table
                 if ($check) {
                     updateNodeStatus($handlednodes, \@allerrornodes);
                 }
 
                 Time::HiRes::sleep(0.1);
             }
-# Pick out the hcp which has least processes
+            # Pick out the hcp which has least processes
             my $least_processes = $request->{maxssh};
             my $least_hcp;
             my $got_one = 0;
@@ -245,7 +245,7 @@ sub process_command {
                 }
 
                 if (!$hasnode) {
-# There are no node in the $nodes
+                    # There are no node in the $nodes
                     goto ENDOFFORK;
                 }
 
@@ -255,7 +255,7 @@ sub process_command {
                     my $handlednodes={};
                     child_response( $callback, $fds, $handlednodes);
 
-#update the node status to the nodelist.status table
+                    #update the node status to the nodelist.status table
                     if ($check) {
                         updateNodeStatus($handlednodes, \@allerrornodes);
                     }
@@ -287,17 +287,17 @@ sub process_command {
                 my $handlednodes={};
                 child_response( $callback, $fds, $handlednodes);
 
-#update the node status to the nodelist.status table
+                #update the node status to the nodelist.status table
                 if ($check) {
                     updateNodeStatus($handlednodes, \@allerrornodes);
                 }
 
                 Time::HiRes::sleep(0.1);
             }
-###################################
-# sleep between connects to same
-# HMC/IVM so as not to overwelm it
-###################################
+            ###################################
+            # sleep between connects to same
+            # HMC/IVM so as not to overwelm it
+            ###################################
             if ( $hw ne @$_[0] ) {
                 $sessions = 1;
             } elsif ( $sessions++ >= $request->{maxssh} ) {
@@ -315,14 +315,14 @@ sub process_command {
     }
 
 ENDOFFORK:
-#######################################
-# Process responses from children
-#######################################
+    #######################################
+    # Process responses from children
+    #######################################
     while ( $fds->count > 0 or $children > 0 ) {
         my $handlednodes={};
         child_response( $callback, $fds, $handlednodes);
 
-#update the node status to the nodelist.status table
+        #update the node status to the nodelist.status table
         if ($check) {
             updateNodeStatus($handlednodes, \@allerrornodes);
         }
@@ -330,12 +330,12 @@ ENDOFFORK:
         Time::HiRes::sleep(0.1);
     }
 
-#drain one more time
+    #drain one more time
     my $rc=1;
     while ( $rc>0 ) {
         my $handlednodes={};
         $rc=child_response( $callback, $fds, $handlednodes);
-#update the node status to the nodelist.status table
+        #update the node status to the nodelist.status table
         if ($check) {
             updateNodeStatus($handlednodes, \@allerrornodes);
         }
@@ -348,8 +348,8 @@ ENDOFFORK:
     }
 
     if ($check) {
-#print "allerrornodes=@allerrornodes\n";
-#revert the status back for there is no-op for the nodes
+        #print "allerrornodes=@allerrornodes\n";
+        #revert the status back for there is no-op for the nodes
         my %old=(); 
         foreach my $node (@allerrornodes) {
             my $stat=$oldnodestatus{$node};
@@ -409,16 +409,16 @@ sub child_response {
     foreach my $rfh (@ready_fds) {
         my $data = <$rfh>;
 
-#################################
-# Read from child process
-#################################
+        #################################
+        # Read from child process
+        #################################
         if ( defined( $data )) {
             while ($data !~ /ENDOFFREEZE6sK4ci/) {
                 $data .= <$rfh>;
             }
             my $responses = thaw($data);
             foreach ( @$responses ) {
-#save the nodes that has errors for node status monitoring
+                #save the nodes that has errors for node status monitoring
                 if ((exists($_->{errorcode})) && ($_->{errorcode} != 0))  { 
                     if ($errornodes) { $errornodes->{$_->{node}->[0]->{name}->[0]}=-1; } 
                 } else {
@@ -428,14 +428,14 @@ sub child_response {
             }
             next;
         }
-#################################
-# Done - close handle
-#################################
+        #################################
+        # Done - close handle
+        #################################
         $fds->remove($rfh);
         close($rfh);
     }
     yield; #Try to avoid useless iterations as much as possible
-        return $rc;
+    return $rc;
 } 
 
 
@@ -450,16 +450,16 @@ sub resolve_hcp {
     my $tab       = ($request->{hwtype} eq "fsp" or $request->{hwtype} eq "bpa") ? "ppcdirect" : "ppchcp";
     my $db        = xCAT::Table->new( $tab );
 
-####################################
-# Database not defined 
-####################################
+    ####################################
+    # Database not defined 
+    ####################################
     if ( !defined( $db )) {
         send_msg( $request, 1, sprintf( $errmsg{DB_UNDEF}, $tab ));
         return undef;
     }
-####################################
-# Process each node
-####################################
+    ####################################
+    # Process each node
+    ####################################
     foreach my $hcp ( @$noderange ) {
         my ($ent) = $db->getAttribs( {hcp=>$hcp},"hcp" );
 
@@ -468,15 +468,15 @@ sub resolve_hcp {
             send_msg( $request, 1, $msg );
             next;
         }
-################################
-# Get userid and password 
-################################
+        ################################
+        # Get userid and password 
+        ################################
         my @cred = xCAT::PPCdb::credentials( $hcp, $request->{hwtype} );
         $request->{$hcp}{cred} = \@cred;
 
-################################
-# Save values
-################################
+        ################################
+        # Save values
+        ################################
         push @nodegroup,[$hcp];
     }
     return( \@nodegroup );
@@ -498,28 +498,28 @@ sub preprocess_nodes {
     my %tabs      = ();
     my $netwk;
 
-########################################
-# Special cases
-#   rscan - Nodes are hardware control pts 
-#   Direct-attached FSP 
-########################################
+    ########################################
+    # Special cases
+    #   rscan - Nodes are hardware control pts 
+    #   Direct-attached FSP 
+    ########################################
     if (( $request->{command} =~ /^(rscan|rspconfig)$/ ) or
             ( $request->{hwtype} eq "fsp" or $request->{hwtype} eq "bpa")) {
         my $result = resolve_hcp( $request, $noderange );
         return( $result );
     }
-##########################################
-# Special processing - rnetboot 
-##########################################
+    ##########################################
+    # Special processing - rnetboot 
+    ##########################################
     if ( $request->{command} eq "rnetboot" ) { 
         $netwk = resolve_netwk( $request, $noderange );
         if ( !defined( %$netwk )) {
             return undef;
         }
     }
-##########################################
-# Open databases needed
-##########################################
+    ##########################################
+    # Open databases needed
+    ##########################################
     foreach ( qw(ppc vpd nodetype) ) {
         $tabs{$_} = xCAT::Table->new($_);
 
@@ -529,32 +529,32 @@ sub preprocess_nodes {
         }
     }
 
-####################
-# $f1 and $f2 are the flags for rflash, to check if there are BPAs and CECs at the same time.
-#################
+    ####################
+    # $f1 and $f2 are the flags for rflash, to check if there are BPAs and CECs at the same time.
+    #################
     my $f1 = 0;	
     my $f2 = 0;	
-##########################################
-# Group nodes
-##########################################
+    ##########################################
+    # Group nodes
+    ##########################################
     foreach my $node ( @$noderange ) {
         my $d = resolve( $request, $node, \%tabs );
 
-######################################
-# Error locating node attributes
-######################################
+        ######################################
+        # Error locating node attributes
+        ######################################
         if ( ref($d) ne 'ARRAY' ) {
             send_msg( $request, 1, "$node: $d");
             next;
         }
-######################################
-# Get data values 
-######################################
+        ######################################
+        # Get data values 
+        ######################################
         my $hcp  = @$d[3];
         my $mtms = @$d[2];
-######################################
-# Special case for rflash
-######################################
+        ######################################
+        # Special case for rflash
+        ######################################
         if ( $request->{command} eq "rflash" ) {
             if(@$d[4] =~/^(fsp|lpar)$/) {
                 $f1 = 1;
@@ -592,33 +592,33 @@ sub preprocess_nodes {
         return undef; 
     }
 
-##########################################
-# Get userid and password
-##########################################
+    ##########################################
+    # Get userid and password
+    ##########################################
     while (my ($hcp,$hash) = each(%nodehash) ) {   
         my @cred = xCAT::PPCdb::credentials( $hcp, $request->{hwtype} );
         $request->{$hcp}{cred} = \@cred;
     } 
-##########################################
-# Group the nodes - we will fork one 
-# process per nodegroup array element. 
-##########################################
+    ##########################################
+    # Group the nodes - we will fork one 
+    # process per nodegroup array element. 
+    ##########################################
 
-##########################################
-# These commands are grouped on an
-# LPAR-by-LPAR basis - fork one process
-# per LPAR.  
-##########################################
-    if ( $method =~ /^(getmacs|rnetboot)$/ ) {
+    ##########################################
+    # These commands are grouped on an
+    # LPAR-by-LPAR basis - fork one process
+    # per LPAR.  
+    ##########################################
+    if ( ($method =~ /^(getmacs)$/ && exists( $request->{opt}->{D} )) || ($method =~ /^(rnetboot)$/) ) {
         while (my ($hcp,$hash) = each(%nodehash) ) {    
             @nodegroup = ();
             while (my ($mtms,$h) = each(%$hash) ) {
                 while (my ($lpar,$d) = each(%$h)) {
                     push @$d, $lpar;
 
-##########################
-# Save network info
-##########################
+                    ##########################
+                    # Save network info
+                    ##########################
                     if ( $method =~ /^rnetboot$/ ) {
                         push @$d, $netwk->{$lpar}; 
                     }
@@ -633,14 +633,14 @@ sub preprocess_nodes {
         return( \%hcpgroup );
     }
 
-##########################################
-# Power control commands are grouped 
-# by CEC which is the smallest entity 
-# that commands can be sent to in parallel.  
-# If commands are sent in parallel to a
-# single CEC, the CEC itself will serialize 
-# them - fork one process per CEC.
-##########################################
+    ##########################################
+    # Power control commands are grouped 
+    # by CEC which is the smallest entity 
+    # that commands can be sent to in parallel.  
+    # If commands are sent in parallel to a
+    # single CEC, the CEC itself will serialize 
+    # them - fork one process per CEC.
+    ##########################################
     elsif ( $method =~ /^powercmd/ ) {
         while (my ($hcp,$hash) = each(%nodehash) ) {    
             while (my ($mtms,$h) = each(%$hash) ) {    
@@ -649,11 +649,11 @@ sub preprocess_nodes {
         }
         return( \@nodegroup );
     }
-##########################################
-# All other commands are grouped by
-# hardware control point - fork one
-# process per hardware control point.
-##########################################
+    ##########################################
+    # All other commands are grouped by
+    # hardware control point - fork one
+    # process per hardware control point.
+    ##########################################
     while (my ($hcp,$hash) = each(%nodehash) ) {    
         push @nodegroup,[$hcp,$hash]; 
     }
@@ -673,25 +673,25 @@ sub resolve_netwk {
     my %result    = ();
     my $ip;
 
-#####################################
-# Network attributes undefined 
-#####################################
+    #####################################
+    # Network attributes undefined 
+    #####################################
     if ( !%nethash ) {
         send_msg( $request,1,sprintf( $errmsg{NODE_UNDEF}, "networks" ));
         return undef;
     }
-#####################################
-# mac database undefined
-#####################################
+    #####################################
+    # mac database undefined
+    #####################################
     if ( !defined( $tab )) {
         send_msg( $request, 1, sprintf( $errmsg{DB_UNDEF}, "mac" ));
         return undef;
     }
 
     foreach ( @$noderange ) {
-#################################
-# Get gateway (-G)
-#################################
+        #################################
+        # Get gateway (-G)
+        #################################
         if ( !exists( $nethash{$_} )) {
             my $msg = sprintf( "$_: $errmsg{NODE_UNDEF}", "networks");
             send_msg( $request, 1, $msg );
@@ -710,9 +710,9 @@ sub resolve_netwk {
         }
         my $gateway_ip = @$ip[1];
 
-#################################
-# Get server (-S)
-#################################
+        #################################
+        # Get server (-S)
+        #################################
         my $server = xCAT::Utils->GetMasterNodeName( $_ );
         if ( $server == 1 ) {
             send_msg( $request, 1, "$_: Unable to identify master" );
@@ -725,9 +725,9 @@ sub resolve_netwk {
         }
         my $server_ip = @$ip[1];
 
-#################################
-# Get client (-C)
-#################################
+        #################################
+        # Get client (-C)
+        #################################
         $ip = xCAT::Utils::toIP( $_ ); 
         if ( @$ip[0] != 0 ) {
             send_msg( $request, 1, "$_: Cannot resolve '$_'" );
@@ -735,18 +735,18 @@ sub resolve_netwk {
         }
         my $client_ip = @$ip[1];
 
-#################################
-# Get mac-address (-m)
-#################################
+        #################################
+        # Get mac-address (-m)
+        #################################
         my ($ent) = $tab->getNodeAttribs( $_, ['mac'] );
         if ( !defined($ent) ) {
             my $msg = sprintf( "$_: $errmsg{NO_ATTR}","mac","mac");
             send_msg( $request, 1, $msg );
             next;
         }
-#################################
-# Save results 
-#################################
+        #################################
+        # Save results 
+        #################################
         $result{$_}{gateway} = $gateway_ip;
         $result{$_}{server}  = $server_ip;
         $result{$_}{client}  = $client_ip;
@@ -767,22 +767,22 @@ sub resolve {
     my @attribs = qw(id pprofile parent hcp);
     my @values  = ();
 
-#################################
-# Get node type 
-#################################
+    #################################
+    # Get node type 
+    #################################
     my $ent = $tabs->{nodetype}->getNodeAttribs($node,[qw(nodetype node)]);
     if ( !defined( $ent )) {
         return( sprintf( $errmsg{NODE_UNDEF}, "nodetype" ));
     }
-#################################
-# Check for type
-#################################
+    #################################
+    # Check for type
+    #################################
     if ( !exists( $ent->{nodetype} )) {
         return( sprintf( $errmsg{NO_ATTR}, "nodetype","nodetype" ));
     }
-#################################
-# Check for valid "type"
-#################################
+    #################################
+    # Check for valid "type"
+    #################################
     my ($type) = grep( 
             /^$::NODETYPE_LPAR|$::NODETYPE_OSI|$::NODETYPE_BPA|$::NODETYPE_FSP$/, 
             split /,/, $ent->{nodetype} );
@@ -790,17 +790,17 @@ sub resolve {
     if ( !defined( $type )) {
         return( "Invalid node type: $ent->{nodetype}" );
     }
-#################################
-# Get attributes 
-#################################
+    #################################
+    # Get attributes 
+    #################################
     my ($att) = $tabs->{ppc}->getNodeAttribs( $node, \@attribs );
 
     if ( !defined( $att )) { 
         return( sprintf( $errmsg{NODE_UNDEF}, "ppc" )); 
     }
-#################################
-# Special lpar processing 
-#################################
+    #################################
+    # Special lpar processing 
+    #################################
     if ( $type =~ /^$::NODETYPE_OSI|$::NODETYPE_LPAR$/ ) {
         $att->{bpa}  = 0;
         $att->{type} = "lpar";
@@ -809,16 +809,16 @@ sub resolve {
         if ( !exists( $att->{parent} )) {
             return( sprintf( $errmsg{NO_ATTR}, "parent", "ppc" )); 
         }
-#############################
-# Get BPA (if any)
-#############################
+        #############################
+        # Get BPA (if any)
+        #############################
         if (( $request->{command} eq "rvitals" ) &&
                 ( $request->{method}  =~ /^all|temp$/ )) { 
             my ($ent) = $tabs->{ppc}->getNodeAttribs( $att->{parent},['parent']);
 
-#############################
-# Find MTMS in vpd database 
-#############################
+            #############################
+            # Find MTMS in vpd database 
+            #############################
             if (( defined( $ent )) && exists( $ent->{parent} )) {
                 my @attrs = qw(mtm serial);
                 my ($vpd) = $tabs->{vpd}->getNodeAttribs($ent->{parent},\@attrs);
@@ -826,9 +826,9 @@ sub resolve {
                 if ( !defined( $vpd )) {
                     return( sprintf( $errmsg{NO_UNDEF}, "vpd" )); 
                 }
-########################
-# Verify attributes
-########################
+                ########################
+                # Verify attributes
+                ########################
                 foreach ( @attrs ) {
                     if ( !exists( $vpd->{$_} )) {
                         return( sprintf( $errmsg{NO_ATTR}, $_, "vpd" ));
@@ -838,9 +838,9 @@ sub resolve {
             }
         }
     }
-#################################
-# Optional and N/A fields 
-#################################
+    #################################
+    # Optional and N/A fields 
+    #################################
     elsif ( $type =~ /^$::NODETYPE_FSP$/ ) {
         $att->{pprofile} = 0;
         $att->{id}       = 0;
@@ -859,18 +859,18 @@ sub resolve {
         $att->{node}     = $node;
         $att->{type}     = $type;
     }
-#################################
-# Find MTMS in vpd database 
-#################################
+    #################################
+    # Find MTMS in vpd database 
+    #################################
     my @attrs = qw(mtm serial);
     my ($vpd) = $tabs->{vpd}->getNodeAttribs($att->{node}, \@attrs );
 
     if ( !defined( $vpd )) {
         return( sprintf( $errmsg{NODE_UNDEF}, "vpd: ($att->{node})" )); 
     }
-################################
-# Verify both vpd attributes
-################################
+    ################################
+    # Verify both vpd attributes
+    ################################
     foreach ( @attrs ) {
         if ( !exists( $vpd->{$_} )) {
             return( sprintf( $errmsg{NO_ATTR}, $_, "vpd: ($att->{node})" ));
@@ -878,17 +878,17 @@ sub resolve {
     }
     $att->{fsp} = "$vpd->{mtm}*$vpd->{serial}";
 
-#################################
-# Verify required attributes
-#################################
+    #################################
+    # Verify required attributes
+    #################################
     foreach my $at ( @attribs ) {
         if ( !exists( $att->{$at} )) {
             return( sprintf( $errmsg{NO_ATTR}, $at, "ppc" ));
         } 
     }
-#################################
-# Build array of data 
-#################################
+    #################################
+    # Build array of data 
+    #################################
     foreach ( qw(id pprofile fsp hcp type bpa) ) {
         push @values, $att->{$_};
     }
@@ -906,25 +906,25 @@ sub fork_cmd {
     my $nodes   = shift;
     my $request = shift;
 
-#######################################
-# Pipe childs output back to parent
-#######################################
+    #######################################
+    # Pipe childs output back to parent
+    #######################################
     my $parent;
     my $child;
     pipe $parent, $child;
     my $pid = xCAT::Utils->xfork;
 
     if ( !defined($pid) ) {
-###################################
-# Fork error
-###################################
+        ###################################
+        # Fork error
+        ###################################
         send_msg( $request, 1, "Fork error: $!" );
         return undef;
     }
     elsif ( $pid == 0 ) {
-###################################
-# Child process
-###################################
+        ###################################
+        # Child process
+        ###################################
         close( $parent );
         $request->{pipe} = $child;
 
@@ -932,9 +932,9 @@ sub fork_cmd {
         exit(0);
     }
     else {
-###################################
-# Parent process
-###################################
+        ###################################
+        # Parent process
+        ###################################
         close( $child );
         return( $parent, $pid );
     }
@@ -956,14 +956,14 @@ sub invoke_cmd {
     my $verbose_log;
     my @outhash;
 
-########################################
-# Direct-attached FSP handler 
-########################################
+    ########################################
+    # Direct-attached FSP handler 
+    ########################################
     if ( $hwtype eq "fsp" or $hwtype eq "bpa") {
 
-####################################
-# Dynamically load FSP module
-####################################
+        ####################################
+        # Dynamically load FSP module
+        ####################################
         eval { require xCAT::PPCfsp };
         if ( $@ ) {
             send_msg( $request, 1, $@ );
@@ -971,18 +971,18 @@ sub invoke_cmd {
         }
         my @exp = xCAT::PPCfsp::connect( $request, $host );
 
-####################################
-# Error connecting 
-####################################
+        ####################################
+        # Error connecting 
+        ####################################
         if ( ref($exp[0]) ne "LWP::UserAgent" ) {
             send_msg( $request, 1, $exp[0] );
             return;
         }
         my $result = xCAT::PPCfsp::handler( $host, $request, \@exp );
 
-####################################
-# Output verbose Perl::LWP 
-####################################
+        ####################################
+        # Output verbose Perl::LWP 
+        ####################################
         if ( $verbose ) {
             $verbose_log = $exp[3];
 
@@ -996,61 +996,61 @@ sub invoke_cmd {
         return;
     }
 
-########################################
-# HMC and IVM-managed handler
-# Connect to list of remote servers
-########################################
+    ########################################
+    # HMC and IVM-managed handler
+    # Connect to list of remote servers
+    ########################################
     foreach ( split /,/, $host ) {
         @exp = xCAT::PPCcli::connect( $request, $hwtype, $_ );
 
-####################################
-# Successfully connected 
-####################################
+        ####################################
+        # Successfully connected 
+        ####################################
         if ( ref($exp[0]) eq "Expect" ) {
             last;
         }
     }
-########################################
-# Error connecting 
-########################################
+    ########################################
+    # Error connecting 
+    ########################################
     if ( ref($exp[0]) ne "Expect" ) {
         send_msg( $request, 1, $exp[0] );
         return;
     }
-########################################
-# Process specific command 
-########################################
+    ########################################
+    # Process specific command 
+    ########################################
     my $result = runcmd( $request, $nodes, \@exp );
 
-########################################
-# Close connection to remote server
-########################################
+    ########################################
+    # Close connection to remote server
+    ########################################
     xCAT::PPCcli::disconnect( \@exp );
 
-########################################
-# Get verbose Expect output
-########################################
+    ########################################
+    # Get verbose Expect output
+    ########################################
     if ( $verbose ) {
         $verbose_log = $exp[6];
     }
-########################################
-# Return error
-######################################## 
+    ########################################
+    # Return error
+    ######################################## 
     if ( ref($result) ne 'ARRAY' ) {
         send_msg( $request, 1, $$verbose_log.$result );
         return;
     }
-########################################
-# Prepend verbose output 
-########################################
+    ########################################
+    # Prepend verbose output 
+    ########################################
     if ( defined( $verbose_log )) {
         my %output;
         $output{data} = [$$verbose_log];
         push @outhash, \%output;
     }
-########################################
-# Send result back to parent process
-########################################
+    ########################################
+    # Send result back to parent process
+    ########################################
     if ( @$result[0] eq "FORMATDATA6sK4ci" ) {
         my $out = $request->{pipe};
 
@@ -1059,9 +1059,9 @@ sub invoke_cmd {
         print $out "\nENDOFFREEZE6sK4ci\n";
         return;
     }
-########################################
-# Format and send back to parent
-########################################
+    ########################################
+    # Format and send back to parent
+    ########################################
     foreach ( @$result ) {
         my %output;
         $output{node}->[0]->{name}->[0] = @$_[0];
@@ -1086,22 +1086,22 @@ sub runcmd {
     my $hwtype  = $request->{hwtype};
     my $modname = $modules{$cmd};
 
-######################################
-# Command not supported
-######################################
+    ######################################
+    # Command not supported
+    ######################################
     if ( !defined( $modname )) {
         return( ["$cmd not a supported command by $hwtype method"] );
     }   
-######################################
-# Load specific module
-######################################
+    ######################################
+    # Load specific module
+    ######################################
     eval "require $modname";
     if ( $@ ) {
         return( [$@] );
     }
-######################################
-# Invoke method 
-######################################
+    ######################################
+    # Invoke method 
+    ######################################
     no strict 'refs';
     my $result = ${$modname."::"}{$method}->($request,@_);
     use strict;
@@ -1118,14 +1118,14 @@ sub preprocess_request {
 
     my $package  = shift;
     my $req      = shift;
-#if ($req->{_xcatdest}) { return [$req]; }    #exit if preprocessed
+    #if ($req->{_xcatdest}) { return [$req]; }    #exit if preprocessed
     if ($req->{_xcatpreprocessed}->[0] == 1 ) { return [$req]; }
     my $callback = shift;
     my @requests;
 
-#####################################
-# Parse arguments
-#####################################
+    #####################################
+    # Parse arguments
+    #####################################
     my $opt = parse_args($package, $req, $callback);
     if ( ref($opt) eq 'ARRAY' ) 
     {
@@ -1135,14 +1135,14 @@ sub preprocess_request {
 
     $req->{opt} = $opt;
 
-####################################
-# Get hwtype 
-####################################
+    ####################################
+    # Get hwtype 
+    ####################################
     $package =~ s/xCAT_plugin:://;
 
-####################################
-# Prompt for usage if needed and on MN
-####################################
+    ####################################
+    # Prompt for usage if needed and on MN
+    ####################################
     my $noderange = $req->{node}; #Should be arrayref
         my $command = $req->{command}->[0];
     my $extrargs = $req->{arg};
@@ -1166,10 +1166,10 @@ sub preprocess_request {
     }   
 
 
-##################################################################
-# get the HCPs for the LPARs in order to figure out which service 
-# nodes to send the requests to
-###################################################################
+    ##################################################################
+    # get the HCPs for the LPARs in order to figure out which service 
+    # nodes to send the requests to
+    ###################################################################
     my $hcptab_name = ($package eq "fsp" or $package eq "bpa") ? "ppcdirect" : "ppchcp";
     my $hcptab  = xCAT::Table->new( $hcptab_name );
     unless ($hcptab ) {
@@ -1177,7 +1177,7 @@ sub preprocess_request {
         $req = {};
         return;
     }
-# Check if each node is hcp 
+    # Check if each node is hcp 
     my %hcp_hash=();
     my @missednodes=();
     foreach ( @$noderange ) {
@@ -1189,7 +1189,7 @@ sub preprocess_request {
         push @{$hcp_hash{$_}{nodes}}, $_;
     }
 
-#check if the left-over nodes are lpars
+    #check if the left-over nodes are lpars
     if (@missednodes > 0) {
         my $ppctab = xCAT::Table->new("ppc");
         unless ($ppctab) { 
@@ -1208,29 +1208,29 @@ sub preprocess_request {
         }
     }
 
-# find service nodes for the HCPs
-# build an individual request for each service node
-my $service  = "xcat";
-my @hcps=keys(%hcp_hash);
-my $sn = xCAT::Utils->get_ServiceNode(\@hcps, $service, "MN");
+    # find service nodes for the HCPs
+    # build an individual request for each service node
+    my $service  = "xcat";
+    my @hcps=keys(%hcp_hash);
+    my $sn = xCAT::Utils->get_ServiceNode(\@hcps, $service, "MN");
 
-# build each request for each service node
-foreach my $snkey (keys %$sn)
-{
-#$callback->({data=>["The service node $snkey "]});
-    my $reqcopy = {%$req};
-    $reqcopy->{'_xcatdest'} = $snkey;
-    $reqcopy->{_xcatpreprocessed}->[0] = 1;
-    my $hcps1=$sn->{$snkey};
-    my @nodes=();
-    foreach (@$hcps1) { 
-        push @nodes, @{$hcp_hash{$_}{nodes}};
+    # build each request for each service node
+    foreach my $snkey (keys %$sn)
+    {
+        #$callback->({data=>["The service node $snkey "]});
+        my $reqcopy = {%$req};
+        $reqcopy->{'_xcatdest'} = $snkey;
+        $reqcopy->{_xcatpreprocessed}->[0] = 1;
+        my $hcps1=$sn->{$snkey};
+        my @nodes=();
+        foreach (@$hcps1) { 
+            push @nodes, @{$hcp_hash{$_}{nodes}};
+        }
+        $reqcopy->{node} = \@nodes;
+        #print "nodes=@nodes\n";
+        push @requests, $reqcopy;
     }
-    $reqcopy->{node} = \@nodes;
-#print "nodes=@nodes\n";
-    push @requests, $reqcopy;
-}
-return \@requests;
+    return \@requests;
 }
 ####################################
 # Parse arguments
@@ -1241,14 +1241,14 @@ sub parse_args
     my $req     = shift;
     my $callback= shift;
     $package =~ s/xCAT_plugin:://;
-#    if ( exists $req->{opt})
-#    {
-#        return $req->{opt};
-#    }
+    #    if ( exists $req->{opt})
+    #    {
+    #        return $req->{opt};
+    #    }
 
-#################################
-# To match the old logic
-##################################
+    #################################
+    # To match the old logic
+    ##################################
     my $command = $req->{command}->[0];
     my $stdin   = $req->{stdin}->[0];
     $req->{command}  = $command;
@@ -1274,28 +1274,28 @@ sub process_request {
     my $req      = shift;
     my $callback = shift;
 
-####################################
-# Get hwtype 
-####################################
+    ####################################
+    # Get hwtype 
+    ####################################
     $package =~ s/xCAT_plugin:://;
 
-####################################
-# Build hash to pass around 
-####################################
+    ####################################
+    # Build hash to pass around 
+    ####################################
     my $request = {%$req};
     $request->{command} = $req->{command}->[0];
     $request->{stdin}   = $req->{stdin}->[0]; 
     $request->{hwtype}  = $package;
     $request->{callback}= $callback;
-####################################
-# Option -V for verbose output
-####################################
+    ####################################
+    # Option -V for verbose output
+    ####################################
     if ( exists( $request->{opt}->{V} )) {
         $request->{verbose} = 1;
     }
-####################################
-# Process remote command
-####################################
+    ####################################
+    # Process remote command
+    ####################################
     process_command( $request );
 }
 
@@ -1333,31 +1333,31 @@ sub sshcmds_on_hmc
 
     my $valid_ip;
     foreach my $individual_ip ( split /,/, $ip ) {
-################################
-# Get userid and password 
-################################
+        ################################
+        # Get userid and password 
+        ################################
         my @cred = xCAT::PPCdb::credentials( $individual_ip, "hmc" );
         $request{$individual_ip}{cred} = \@cred;
 
         @exp = xCAT::PPCcli::connect( \%request, 'hmc', $individual_ip);
-####################################
-# Successfully connected 
-####################################
+        ####################################
+        # Successfully connected 
+        ####################################
         if ( ref($exp[0]) eq "Expect" ) {
             $valid_ip = $individual_ip;
             last;
         }
     }
 
-########################################
-# Error connecting 
-########################################
+    ########################################
+    # Error connecting 
+    ########################################
     if ( ref($exp[0]) ne "Expect" ) {
         return ([1,@cmds]);
     }
-########################################
-# Process specific command 
-########################################
+    ########################################
+    # Process specific command 
+    ########################################
     for my $cmd ( keys %handled)
     {
         my $result;
@@ -1368,9 +1368,9 @@ sub sshcmds_on_hmc
         }
         push @data, @$result[0]; 
     }
-########################################
-# Close connection to remote server
-########################################
+    ########################################
+    # Close connection to remote server
+    ########################################
     xCAT::PPCcli::disconnect( \@exp );
 
     return ([0, undef, \@data]);
@@ -1417,26 +1417,26 @@ sub updconf_in_asm
     my $valid_ip;
     my @exp;
     foreach my $individual_ip ( split /,/, $ip ) {
-################################
-# Get userid and password 
-################################
+        ################################
+        # Get userid and password 
+        ################################
         my @cred = xCAT::PPCdb::credentials( $individual_ip, lc($target_dev->{'type'}));
         $request{$individual_ip}{cred} = \@cred;
         $request{node} = [$individual_ip];  
 
         @exp = xCAT::PPCfsp::connect(\%request, $individual_ip);
-####################################
-# Successfully connected 
-####################################
+        ####################################
+        # Successfully connected 
+        ####################################
         if ( ref($exp[0]) eq "LWP::UserAgent" ) {
             $valid_ip = $individual_ip;
             last;
         }
     }
 
-####################################
-# Error connecting 
-####################################
+    ####################################
+    # Error connecting 
+    ####################################
     if ( ref($exp[0]) ne "LWP::UserAgent" ) {
         return ([1,@cmds]);
     }