extras/vpp_config/vpplib/VppGrubUtil.py

   1 # Copyright (c) 2016 Cisco and/or its affiliates.
   2 # Licensed under the Apache License, Version 2.0 (the "License");
   3 # you may not use this file except in compliance with the License.
   4 # You may obtain a copy of the License at:
   5 #
   6 #     http://www.apache.org/licenses/LICENSE-2.0
   7 #
   8 # Unless required by applicable law or agreed to in writing, software
   9 # distributed under the License is distributed on an "AS IS" BASIS,
  10 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  11 # See the License for the specific language governing permissions and
  12 # limitations under the License.
  13
  14 """VPP Grub Utility Library."""
  15
  16 import re
  17
  18 from vpplib.VPPUtil import VPPUtil
  19
  20 __all__ = ['VppGrubUtil']
  21
  22
  23 class VppGrubUtil(object):
  24     """ VPP Grub Utilities."""
  25
  26     def _get_current_cmdline(self):
  27         """
  28         Using /proc/cmdline return the current grub cmdline
  29
  30         :returns: The current grub cmdline
  31         :rtype: string
  32         """
  33
  34         # Get the memory information using /proc/meminfo
  35         cmd = 'sudo cat /proc/cmdline'
  36         (ret, stdout, stderr) = VPPUtil.exec_command(cmd)
  37         if ret != 0:
  38             raise RuntimeError('{} on node {} {} {}'.
  39                                format(cmd, self._node['host'],
  40                                       stdout, stderr))
  41
  42         self._current_cmdline = stdout.strip('\n')
  43
  44     def _get_default_cmdline(self):
  45         """
  46         Using /etc/default/grub return the default grub cmdline
  47
  48         :returns: The default grub cmdline
  49         :rtype: string
  50         """
  51
  52         # Get the default grub cmdline
  53         rootdir = self._node['rootdir']
  54         gfile = self._node['cpu']['grub_config_file']
  55         grubcmdline = self._node['cpu']['grubcmdline']
  56         cmd = 'cat {}'.format(rootdir + gfile)
  57         (ret, stdout, stderr) = VPPUtil.exec_command(cmd)
  58         if ret != 0:
  59             raise RuntimeError('{} Executing failed on node {} {}'.
  60                                format(cmd, self._node['host'], stderr))
  61
  62         # Get the Default Linux command line, ignoring commented lines
  63         lines = stdout.split('\n')
  64         for line in lines:
  65             if line == '' or line[0] == '#':
  66                 continue
  67             ldefault = re.findall(r'{}=.+'.format(grubcmdline), line)
  68             if ldefault:
  69                 self._default_cmdline = ldefault[0]
  70                 break
  71
  72     def get_current_cmdline(self):
  73         """
  74         Returns the saved grub cmdline
  75
  76         :returns: The saved grub cmdline
  77         :rtype: string
  78         """
  79         return self._current_cmdline
  80
  81     def get_default_cmdline(self):
  82         """
  83         Returns the default grub cmdline
  84
  85         :returns: The default grub cmdline
  86         :rtype: string
  87         """
  88         return self._default_cmdline
  89
  90     def create_cmdline(self, isolated_cpus):
  91         """
  92         Create the new grub cmdline
  93
  94         :param isolated_cpus: The isolated cpu string
  95         :type isolated_cpus: string
  96         :returns: The command line
  97         :rtype: string
  98         """
  99         grubcmdline = self._node['cpu']['grubcmdline']
 100         cmdline = self._default_cmdline
 101         value = cmdline.split('{}='.format(grubcmdline))[1]
 102         value = value.rstrip('"').lstrip('"')
 103
 104         iommu = re.findall(r'iommu=\w+', value)
 105         pstate = re.findall(r'intel_pstate=\w+', value)
 106         # If there is already some iommu commands set, leave them,
 107         # if not use ours
 108         if iommu == [] and pstate == []:
 109             value = '{} intel_pstate=disable'.format(value)
 110
 111         # Replace isolcpus with ours
 112         isolcpus = re.findall(r'isolcpus=[\w+\-,]+', value)
 113         if not isolcpus:
 114             if isolated_cpus != '':
 115                 value = "{} isolcpus={}".format(value, isolated_cpus)
 116         else:
 117             if isolated_cpus != '':
 118                 value = re.sub(r'isolcpus=[\w+\-,]+',
 119                                'isolcpus={}'.format(isolated_cpus),
 120                                value)
 121             else:
 122                 value = re.sub(r'isolcpus=[\w+\-,]+', '', value)
 123
 124         nohz = re.findall(r'nohz_full=[\w+\-,]+', value)
 125         if not nohz:
 126             if isolated_cpus != '':
 127                 value = "{} nohz_full={}".format(value, isolated_cpus)
 128         else:
 129             if isolated_cpus != '':
 130                 value = re.sub(r'nohz_full=[\w+\-,]+',
 131                                'nohz_full={}'.format(isolated_cpus),
 132                                value)
 133             else:
 134                 value = re.sub(r'nohz_full=[\w+\-,]+', '', value)
 135
 136         rcu = re.findall(r'rcu_nocbs=[\w+\-,]+', value)
 137         if not rcu:
 138             if isolated_cpus != '':
 139                 value = "{} rcu_nocbs={}".format(value, isolated_cpus)
 140         else:
 141             if isolated_cpus != '':
 142                 value = re.sub(r'rcu_nocbs=[\w+\-,]+',
 143                                'rcu_nocbs={}'.format(isolated_cpus),
 144                                value)
 145             else:
 146                 value = re.sub(r'rcu_nocbs=[\w+\-,]+', '', value)
 147
 148         value = value.lstrip(' ').rstrip(' ')
 149         cmdline = '{}="{}"'.format(grubcmdline, value)
 150         return cmdline
 151
 152     def apply_cmdline(self, node, isolated_cpus):
 153         """
 154         Apply cmdline to the default grub file
 155
 156         :param node: Node dictionary with cpuinfo.
 157         :param isolated_cpus: The isolated cpu string
 158         :type node: dict
 159         :type isolated_cpus: string
 160         :return The vpp cmdline
 161         :rtype string
 162         """
 163
 164         vpp_cmdline = self.create_cmdline(isolated_cpus)
 165         if vpp_cmdline == '':
 166             return vpp_cmdline
 167
 168         # Update grub
 169         # Save the original file
 170         rootdir = node['rootdir']
 171         grubcmdline = node['cpu']['grubcmdline']
 172         ofilename = rootdir + node['cpu']['grub_config_file'] + '.orig'
 173         filename = rootdir + node['cpu']['grub_config_file']
 174
 175         # Write the output file
 176         # Does a copy of the original file exist, if not create one
 177         (ret, stdout, stderr) = VPPUtil.exec_command('ls {}'.format(ofilename))
 178         if ret != 0:
 179             if stdout.strip('\n') != ofilename:
 180                 cmd = 'sudo cp {} {}'.format(filename, ofilename)
 181                 (ret, stdout, stderr) = VPPUtil.exec_command(cmd)
 182                 if ret != 0:
 183                     raise RuntimeError('{} failed on node {} {}'.
 184                                        format(cmd, self._node['host'], stderr))
 185
 186         # Get the contents of the current grub config file
 187         cmd = 'cat {}'.format(filename)
 188         (ret, stdout, stderr) = VPPUtil.exec_command(cmd)
 189         if ret != 0:
 190             raise RuntimeError('{} failed on node {} {}'.format(
 191                 cmd,
 192                 self._node['host'],
 193                 stderr))
 194
 195         # Write the new contents
 196         # Get the Default Linux command line, ignoring commented lines
 197         content = ""
 198         lines = stdout.split('\n')
 199         for line in lines:
 200             if line == '':
 201                 content += line + '\n'
 202                 continue
 203             if line[0] == '#':
 204                 content += line + '\n'
 205                 continue
 206
 207             ldefault = re.findall(r'{}=.+'.format(grubcmdline), line)
 208             if ldefault:
 209                 content += vpp_cmdline + '\n'
 210             else:
 211                 content += line + '\n'
 212
 213         content = content.replace(r"`", r"\`")
 214         content = content.rstrip('\n')
 215         cmd = "sudo cat > {0} << EOF\n{1}\n".format(filename, content)
 216         (ret, stdout, stderr) = VPPUtil.exec_command(cmd)
 217         if ret != 0:
 218             raise RuntimeError('{} failed on node {} {}'.format(
 219                 cmd,
 220                 self._node['host'],
 221                 stderr))
 222
 223         return vpp_cmdline
 224
 225     def __init__(self, node):
 226         distro = VPPUtil.get_linux_distro()
 227         if distro[0] == 'Ubuntu':
 228             node['cpu']['grubcmdline'] = 'GRUB_CMDLINE_LINUX_DEFAULT'
 229         else:
 230             node['cpu']['grubcmdline'] = 'GRUB_CMDLINE_LINUX'
 231
 232         self._node = node
 233         self._current_cmdline = ""
 234         self._default_cmdline = ""
 235         self._get_current_cmdline()
 236         self._get_default_cmdline()