498 lines
17 KiB
Python
Executable File
498 lines
17 KiB
Python
Executable File
#
|
|
# firstboot_kdump.py - kdump configuration page for firstboot
|
|
# Copyright 2006 Red Hat, Inc.
|
|
# Author: Jarod Wilson <jwilson@redhat.com>
|
|
# Contributors:
|
|
# Neil Horman <nhorman@redhat.com>
|
|
# Dave Lehman <dlehman@redhat.com>
|
|
#
|
|
#
|
|
# This program is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation; either version 2 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program; if not, write to the Free Software
|
|
# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
|
import sys
|
|
sys.path.append('/usr/share/system-config-kdump/')
|
|
|
|
from gtk import *
|
|
import string
|
|
import os
|
|
import os.path
|
|
import time
|
|
import gtk
|
|
import gobject
|
|
import commands
|
|
from firstboot.config import *
|
|
from firstboot.constants import *
|
|
from firstboot.functions import *
|
|
from firstboot.module import *
|
|
import gettext
|
|
_ = lambda x: gettext.ldgettext("kexec-tools", x)
|
|
N_ = lambda x: x
|
|
|
|
class moduleClass(Module):
|
|
def __init__(self):
|
|
Module.__init__(self)
|
|
self.priority = 100
|
|
self.sidebarTitle = N_("Kdump")
|
|
self.title = N_("Kdump")
|
|
self.reboot = False
|
|
|
|
# runPriority determines the order in which this module runs in firstboot
|
|
runPriority = 70
|
|
moduleName = _("Kdump")
|
|
windowName = moduleName
|
|
reboot = False
|
|
|
|
# possible bootloaders we'll need to adjust
|
|
# bootloader : (config file, kdump offset)
|
|
bootloaders = { "grub" : (["/boot/grub/grub.conf", \
|
|
"/boot/efi/EFI/redhat/grub.conf"], [16, 256]),\
|
|
"grub2" : (["/boot/grub2/grub.cfg", \
|
|
"/boot/efi/EFI/fedora/grub.cfg", \
|
|
"/boot/efi/EFI/redhat/grub.cfg"], [16, 256]),\
|
|
"zipl" : (["/etc/zipl.conf"], [0]),\
|
|
"yaboot" : (["/boot/etc/yaboot.conf"], [32]) }
|
|
bootloader = None
|
|
offset = 0
|
|
|
|
# list of architectures without kdump support
|
|
unsupportedArches = [ "ppc", "s390", "i386", "i586" ]
|
|
|
|
def needsReboot(self):
|
|
return self.reboot
|
|
|
|
# toggle sensitivity of kdump config bits
|
|
def showHideReserve(self, status):
|
|
self.labelKdump.set_sensitive(status)
|
|
self.kdumpMemspin.set_sensitive(status)
|
|
self.totalMem.set_sensitive(status)
|
|
self.systemUsableMem.set_sensitive(status)
|
|
self.labelTotal.set_sensitive(status)
|
|
self.labelSys.set_sensitive(status)
|
|
|
|
# toggle sensitivity of kdump config bits
|
|
def showHide(self, status):
|
|
show_kdumpmem = status
|
|
if self.distro == 'rhel':
|
|
show_autoreserve = self.buttonAuto.get_active()
|
|
if status == True:
|
|
if self.buttonAuto.get_active() == True:
|
|
show_kdumpmem = False
|
|
self.buttonAuto.set_active(show_autoreserve)
|
|
self.buttonManual.set_active(not show_autoreserve)
|
|
self.labelReserve.set_sensitive(status)
|
|
self.buttonAuto.set_sensitive(status)
|
|
self.buttonManual.set_sensitive(status)
|
|
self.showHideReserve(show_kdumpmem)
|
|
self.labelReserved.set_sensitive(status)
|
|
self.labelReservedMemsize.set_sensitive(status)
|
|
self.kdumpEnabled = status
|
|
self.AdvWindow.set_sensitive(status)
|
|
|
|
def on_enableKdumpCheck_toggled(self, *args):
|
|
showHideStatus = self.enableKdumpCheck.get_active()
|
|
self.showHide(showHideStatus)
|
|
|
|
def on_auto_toggled(self, *args):
|
|
if self.distro == 'rhel':
|
|
self.showHideReserve(not self.buttonAuto.get_active())
|
|
|
|
def on_manual_toggled(self, *args):
|
|
if self.distro == 'rhel':
|
|
self.showHideReserve(self.buttonManual.get_active())
|
|
|
|
def updateAvail(self, widget, spin):
|
|
self.reserveMem = eval(string.strip(self.kdumpMemspin.get_text()))
|
|
self.remainingMem = self.availMem - self.reserveMem
|
|
self.systemUsableMem.set_text("%s" % self.remainingMem)
|
|
|
|
def getBootloader(self):
|
|
for (name, (conf, offset)) in self.bootloaders.items():
|
|
i = 0
|
|
for c in conf:
|
|
if os.access(c, os.W_OK):
|
|
self.bootloader = name
|
|
self.offset = i
|
|
return self.bootloader
|
|
i += 1
|
|
|
|
self.offset = None
|
|
self.bootloader = None
|
|
return None
|
|
|
|
def createScreen(self, doDebug = None):
|
|
self.doDebug = doDebug
|
|
|
|
if doDebug:
|
|
print "initializing kdump module"
|
|
|
|
# What kernel are we running?
|
|
self.runningKernel = os.popen("/bin/uname -r").read().strip()
|
|
|
|
# What arch are we running on?
|
|
self.arch = os.popen("/bin/uname -m").read().strip()
|
|
|
|
# Check for a xen kernel, kdump doesn't work w/xen just yet...
|
|
self.xenKernel = self.runningKernel.find("xen")
|
|
|
|
# Fedora or RHEL?
|
|
releaseFile = '/etc/redhat-release'
|
|
lines = open(releaseFile).readlines()
|
|
for line in lines:
|
|
if line.find("Fedora") != -1:
|
|
self.distro = 'fedora'
|
|
else:
|
|
self.distro = 'rhel'
|
|
|
|
# Ascertain how much memory is in the system
|
|
memInfo = open("/proc/meminfo").readlines()
|
|
self.availMem = 0
|
|
for line in memInfo:
|
|
if line.startswith("MemTotal:"):
|
|
self.availMem = int(line.split()[1]) / 1024
|
|
break
|
|
|
|
# Fix up memory calculations if kdump is already on
|
|
cmdLine = open("/proc/cmdline").read()
|
|
self.kdumpOffset = 0
|
|
self.origCrashKernel = ""
|
|
self.kdumpEnabled = False
|
|
chkConfigStatus=commands.getoutput('/bin/systemctl is-enabled kdump.service')
|
|
if chkConfigStatus.find("enabled") > -1:
|
|
self.kdumpEnabled = True
|
|
self.kdumpMemInitial = 0
|
|
|
|
crashString = ""
|
|
kexec_crash_size = open("/sys/kernel/kexec_crash_size").read()
|
|
self.reservedMem = int(kexec_crash_size)/(1024*1024)
|
|
|
|
if cmdLine.find("crashkernel") != -1:
|
|
crashString = filter(lambda t: t.startswith("crashkernel="),
|
|
cmdLine.split())[0].split("=")[1]
|
|
self.origCrashKernel = "crashkernel=%s" % (crashString)
|
|
if self.doDebug:
|
|
print "crashString is %s" % crashString
|
|
if crashString.find("@") != -1:
|
|
(self.kdumpMemInitial, self.kdumpOffset) = [int(m[:-1]) for m in crashString.split("@")]
|
|
else:
|
|
#kdumpMemInitial = -1 means auto reservation
|
|
if self.distro == 'rhel' and self.origCrashKernel == 'crashkernel=auto':
|
|
self.kdumpMemInitial=-1
|
|
else:
|
|
self.kdumpMemInitial=int(crashString[:-1])
|
|
self.kdumpOffset = 0
|
|
if self.kdumpMemInitial != 0:
|
|
self.availMem += self.reservedMem
|
|
self.kdumpEnabled = True
|
|
else:
|
|
self.kdumpEnabled = False
|
|
if self.origCrashKernel.find("crashkernel=") != -1:
|
|
self.kdumpEnabled = True
|
|
|
|
self.initialState = self.kdumpEnabled
|
|
|
|
# Do some sanity-checking and try to present only sane options.
|
|
#
|
|
# Defaults
|
|
lowerBound = 128
|
|
minUsable = 256
|
|
step = 1
|
|
self.enoughMem = True
|
|
if self.arch == 'ia64':
|
|
# ia64 usually needs at *least* 256M, page-aligned... :(
|
|
lowerBound = 256
|
|
minUsable = 512
|
|
step = 256
|
|
elif self.arch == 'ppc64':
|
|
# ppc64 often fails w/128M lately, and we want at least 1G
|
|
# of RAM for normal use, due to 64k page size... :\
|
|
lowerBound = 256
|
|
minUsable = 1024
|
|
|
|
upperBound = (self.availMem - minUsable) - (self.availMem % step)
|
|
|
|
if upperBound < lowerBound:
|
|
self.enoughMem = False
|
|
|
|
# Set spinner to lowerBound unless already set on kernel command line
|
|
if self.kdumpMemInitial == 0 or self.kdumpMemInitial == -1:
|
|
self.kdumpMemInitial = lowerBound
|
|
else:
|
|
# round down to a multiple of step value
|
|
self.kdumpMemInitial = self.kdumpMemInitial - (self.kdumpMemInitial % step)
|
|
|
|
# kdump enable/disable checkbox
|
|
self.enableKdumpCheck = gtk.CheckButton(_("_Enable kdump?"))
|
|
self.enableKdumpCheck.set_alignment(xalign=0, yalign=0)
|
|
|
|
# detected total amount of system memory
|
|
self.totalMem = gtk.Label(_("%s" % self.availMem))
|
|
self.labelTotal = gtk.Label(_("Total System Memory (MB):"))
|
|
self.labelTotal.set_alignment(0.0, 0.5)
|
|
self.labelTotal.set_width_chars(32)
|
|
|
|
# how much ram to reserve for kdump
|
|
self.memAdjustment = gtk.Adjustment(self.kdumpMemInitial, lowerBound, upperBound, step, step, 0)
|
|
self.kdumpMemspin = gtk.SpinButton(self.memAdjustment, 0, 0)
|
|
self.kdumpMemspin.set_update_policy(gtk.UPDATE_IF_VALID)
|
|
self.kdumpMemspin.set_numeric(True)
|
|
self.memAdjustment.connect("value_changed", self.updateAvail, self.kdumpMemspin)
|
|
self.labelKdump = gtk.Label(_("Memory To Be _Reserved (MB):"))
|
|
self.labelKdump.set_use_underline(True)
|
|
self.labelKdump.set_mnemonic_widget(self.kdumpMemspin)
|
|
self.labelKdump.set_alignment(0.0, 0.5)
|
|
|
|
# remaining usable system memory
|
|
self.reserveMem = eval(string.strip(self.kdumpMemspin.get_text()))
|
|
self.remainingMem = self.availMem - self.reserveMem
|
|
self.systemUsableMem = gtk.Label(_("%s" % self.remainingMem))
|
|
self.labelSys = gtk.Label(_("Usable System Memory (MB):"))
|
|
self.labelSys.set_alignment(0.0, 0.5)
|
|
|
|
self.labelReserved=gtk.Label(_("Memory Currently Reserved (MB):"))
|
|
self.labelReservedMemsize=gtk.Label(_("%s" % self.reservedMem))
|
|
self.labelReserved.set_alignment(0.0, 0.5)
|
|
|
|
# rhel crashkernel=auto handling
|
|
if self.distro == 'rhel':
|
|
self.labelReserve = gtk.Label(_("Kdump Memory Reservation:"))
|
|
self.buttonAuto = gtk.RadioButton(None, _("_Automatic"))
|
|
self.buttonManual = gtk.RadioButton(self.buttonAuto, _("_Manual"))
|
|
self.buttonAuto.connect("toggled", self.on_auto_toggled, None)
|
|
self.buttonManual.connect("toggled", self.on_manual_toggled, None)
|
|
self.buttonAuto.set_use_underline(True)
|
|
self.buttonManual.set_use_underline(True)
|
|
self.labelReserve.set_alignment(0.0, 0.5)
|
|
if self.origCrashKernel == 'crashkernel=auto':
|
|
self.buttonAuto.set_active(True)
|
|
self.buttonManual.set_active(False)
|
|
else:
|
|
self.buttonAuto.set_active(False)
|
|
self.buttonManual.set_active(True)
|
|
self.autoinitial = self.buttonAuto.get_active()
|
|
|
|
|
|
# Add an advanced kdump config text widget
|
|
inputbuf = open("/etc/kdump.conf", "r")
|
|
self.AdvConfig = gtk.TextView()
|
|
AdvBuf = gtk.TextBuffer()
|
|
AdvBuf.set_text(inputbuf.read())
|
|
inputbuf.close()
|
|
|
|
self.AdvConfig.set_buffer(AdvBuf)
|
|
self.AdvWindow = gtk.ScrolledWindow()
|
|
self.AdvWindow.set_shadow_type(gtk.SHADOW_IN)
|
|
self.AdvWindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
|
|
self.AdvWindow.set_size_request(500, 300)
|
|
self.AdvWindow.add(self.AdvConfig)
|
|
|
|
self.AdvConfLabel = gtk.Label(_("\nAdvanced kdump configuration"))
|
|
self.AdvConfLabel.set_alignment(0.0, 0.5)
|
|
|
|
self.vbox = gtk.VBox()
|
|
self.vbox.set_size_request(400, 200)
|
|
|
|
# title_pix = loadPixbuf("workstation.png")
|
|
|
|
internalVBox = gtk.VBox()
|
|
internalVBox.set_border_width(10)
|
|
internalVBox.set_spacing(10)
|
|
|
|
label = gtk.Label(_("Kdump is a kernel crash dumping mechanism. In the event of a "
|
|
"system crash, kdump will capture information from your system "
|
|
"that can be invaluable in determining the cause of the crash. "
|
|
"Note that kdump does require reserving a portion of system "
|
|
"memory that will be unavailable for other uses."))
|
|
|
|
label.set_line_wrap(True)
|
|
label.set_alignment(0.0, 0.5)
|
|
label.set_size_request(500, -1)
|
|
internalVBox.pack_start(label, False, True)
|
|
|
|
if self.distro == 'rhel':
|
|
table = gtk.Table(3, 100)
|
|
table.attach(self.enableKdumpCheck, 0, 3, 0, 1, gtk.FILL, gtk.FILL, 5, 5)
|
|
table.attach(self.labelReserve, 0, 1, 1, 2, gtk.FILL)
|
|
table.attach(self.buttonAuto, 1, 2, 1, 2, gtk.FILL, gtk.FILL, 5, 5)
|
|
table.attach(self.buttonManual, 2, 3, 1, 2, gtk.FILL, gtk.FILL, 5, 5)
|
|
table.attach(self.labelReserved, 0, 1, 2, 3, gtk.FILL)
|
|
table.attach(self.labelReservedMemsize, 2, 3, 2, 3, gtk.SHRINK, gtk.FILL, 5, 5)
|
|
table.attach(self.labelKdump, 0, 1, 3, 4, gtk.FILL)
|
|
table.attach(self.kdumpMemspin, 2, 3, 3, 4, gtk.SHRINK, gtk.FILL, 5, 5)
|
|
table.attach(self.labelTotal, 0, 1, 4, 5, gtk.FILL)
|
|
table.attach(self.totalMem, 2, 3, 4, 5, gtk.SHRINK, gtk.FILL, 5, 5)
|
|
table.attach(self.labelSys, 0, 1, 5, 6, gtk.FILL)
|
|
table.attach(self.systemUsableMem, 2, 3, 5, 6, gtk.SHRINK, gtk.FILL, 5, 5)
|
|
table.attach(self.AdvConfLabel, 0, 1, 6, 7, gtk.FILL)
|
|
table.attach(self.AdvWindow, 0, 3, 7, 100, gtk.FILL, gtk.FILL, 5, 5)
|
|
else:
|
|
table = gtk.Table(2, 100)
|
|
table.attach(self.enableKdumpCheck, 0, 2, 0, 1, gtk.FILL, gtk.FILL, 5, 5)
|
|
table.attach(self.labelTotal, 0, 1, 1, 2, gtk.FILL)
|
|
table.attach(self.totalMem, 1, 2, 1, 2, gtk.SHRINK, gtk.FILL, 5, 5)
|
|
|
|
table.attach(self.labelKdump, 0, 1, 2, 3, gtk.FILL)
|
|
table.attach(self.kdumpMemspin, 1, 2, 2, 3, gtk.SHRINK, gtk.FILL, 5, 5)
|
|
|
|
table.attach(self.labelReserved, 0, 1, 3, 4, gtk.FILL)
|
|
table.attach(self.labelReservedMemsize, 1, 2, 3, 4, gtk.SHRINK, gtk.FILL, 5, 5)
|
|
|
|
table.attach(self.labelSys, 0, 1, 4, 5, gtk.FILL)
|
|
table.attach(self.systemUsableMem, 1, 2, 4, 5, gtk.SHRINK, gtk.FILL, 5, 5)
|
|
|
|
table.attach(self.AdvConfLabel, 0, 1, 6, 7, gtk.FILL)
|
|
table.attach(self.AdvWindow, 0, 2, 7, 100, gtk.FILL, gtk.FILL, 5, 5)
|
|
|
|
# disable until user clicks check box, if not already enabled
|
|
if self.initialState is False:
|
|
self.showHide(False)
|
|
else:
|
|
self.enableKdumpCheck.set_active(True)
|
|
self.showHide(True)
|
|
|
|
internalVBox.pack_start(table, True, 15)
|
|
|
|
# toggle sensitivity of Mem items
|
|
self.enableKdumpCheck.connect("toggled", self.on_enableKdumpCheck_toggled)
|
|
|
|
self.vbox.pack_start(internalVBox, False, 15)
|
|
|
|
def grabFocus(self):
|
|
self.enableKdumpCheck.grab_focus()
|
|
|
|
def configChanged(self):
|
|
if self.initialState == self.kdumpEnabled and self.initialState == False:
|
|
return False
|
|
if self.initialState != self.kdumpEnabled \
|
|
or (self.distro == 'rhel' and self.autoinitial != self.buttonAuto.get_active()) \
|
|
or (self.distro == 'rhel' and self.buttonManual.get_active() == True and self.reserveMem != self.kdumpMemInitial) \
|
|
or (self.distro != 'rhel' and self.reserveMem != self.kdumpMemInitial):
|
|
return True
|
|
return False
|
|
|
|
|
|
def apply(self, *args):
|
|
if self.kdumpEnabled:
|
|
self.reserveMem = self.kdumpMemspin.get_value_as_int()
|
|
else:
|
|
self.reserveMem = self.kdumpMemInitial
|
|
self.remainingMem = self.availMem - self.reserveMem
|
|
if self.doDebug:
|
|
print "Running kernel %s on %s architecture" % (self.runningKernel, self.arch)
|
|
if self.enableKdumpCheck.get_active():
|
|
print "System Mem: %s MB Kdump Mem: %s MB Avail Mem: %s MB" % (totalSysMem, self.reserveMem, self.remainingMem)
|
|
else:
|
|
print "Kdump will be disabled"
|
|
|
|
# Before we do other checks we should save the users config
|
|
AdvBuf = self.AdvConfig.get_buffer()
|
|
start, end = AdvBuf.get_bounds()
|
|
outputbuf = open("/etc/kdump.conf", "rw+")
|
|
outputbuf.write(AdvBuf.get_text(start, end))
|
|
outputbuf.close()
|
|
|
|
# Regardless of what else happens we need to be sure to disalbe kdump if its disabled here, or
|
|
# else it will fail during startup
|
|
if (self.enableKdumpCheck.get_active() == False):
|
|
os.system("/bin/systemctl disable kdump.service")
|
|
|
|
# If the user simply doesn't have enough memory for kdump to be viable/supportable, tell 'em
|
|
if self.enoughMem is False and self.kdumpEnabled:
|
|
self.showErrorMessage(_("Sorry, your system does not have enough memory for kdump to be viable!"))
|
|
self.enableKdumpCheck.set_active(False)
|
|
self.showHide(False)
|
|
return RESULT_FAILURE
|
|
# Alert user that we're not going to turn on kdump if they're running a xen kernel
|
|
elif self.xenKernel != -1 and self.kdumpEnabled:
|
|
self.showErrorMessage(_("Sorry, Xen kernels do not support kdump at this time!"))
|
|
self.enableKdumpCheck.set_active(False)
|
|
self.showHide(False)
|
|
return RESULT_FAILURE
|
|
# If there's no kdump support on this arch, let the user know and don't configure
|
|
elif self.arch in self.unsupportedArches:
|
|
self.showErrorMessage(_("Sorry, the %s architecture does not support kdump at this time!" % self.arch))
|
|
self.enableKdumpCheck.set_active(False)
|
|
self.showHide(False)
|
|
return RESULT_FAILURE
|
|
|
|
# Don't alert if nothing has changed
|
|
if self.configChanged() == True:
|
|
dlg = gtk.MessageDialog(None, 0, gtk.MESSAGE_INFO,
|
|
gtk.BUTTONS_YES_NO,
|
|
_("Changing Kdump settings requires rebooting the "
|
|
"system to reallocate memory accordingly. Would you "
|
|
"like to continue with this change and reboot the "
|
|
"system after firstboot is complete?"))
|
|
dlg.set_position(gtk.WIN_POS_CENTER)
|
|
dlg.show_all()
|
|
rc = dlg.run()
|
|
dlg.destroy()
|
|
|
|
if rc != gtk.RESPONSE_YES:
|
|
self.reboot = False
|
|
return RESULT_SUCCESS
|
|
else:
|
|
self.reboot = True
|
|
|
|
# Find bootloader if it exists, and update accordingly
|
|
if self.getBootloader() == None:
|
|
self.showErrorMessage(_("Error! No bootloader config file found, aborting configuration!"))
|
|
self.enableKdumpCheck.set_active(False)
|
|
self.showHide(False)
|
|
return RESULT_FAILURE
|
|
|
|
# Are we adding or removing the crashkernel param?
|
|
if self.kdumpEnabled:
|
|
_reserves = "%iM" % (self.reserveMem)
|
|
if self.distro == 'rhel':
|
|
if self.buttonAuto.get_active() == True:
|
|
_reserves = 'auto'
|
|
|
|
grubbyCmd = "/sbin/grubby --%s --update-kernel=ALL --args=crashkernel=%s" \
|
|
% (self.bootloader, _reserves)
|
|
chkconfigStatus = "enable"
|
|
else:
|
|
grubbyCmd = "/sbin/grubby --%s --update-kernel=ALL --remove-args=%s" \
|
|
% (self.bootloader, self.origCrashKernel)
|
|
chkconfigStatus = "disable"
|
|
|
|
if self.doDebug:
|
|
print "Using %s bootloader with %iM offset" % (self.bootloader, self.offset)
|
|
print "Grubby command would be:\n %s" % grubbyCmd
|
|
print "chkconfig status is %s" % chkconfigStatus
|
|
else:
|
|
os.system(grubbyCmd)
|
|
os.system("/bin/systemctl %s kdump.service" % (chkconfigStatus))
|
|
if self.bootloader == 'yaboot':
|
|
os.system('/sbin/ybin')
|
|
if self.bootloader == 'zipl':
|
|
os.system('/sbin/zipl')
|
|
else:
|
|
self.reboot = False
|
|
|
|
|
|
return RESULT_SUCCESS
|
|
|
|
def showErrorMessage(self, text):
|
|
dlg = gtk.MessageDialog(None, 0, gtk.MESSAGE_ERROR, gtk.BUTTONS_OK, text)
|
|
dlg.set_position(gtk.WIN_POS_CENTER)
|
|
dlg.set_modal(True)
|
|
rc = dlg.run()
|
|
dlg.destroy()
|
|
return None
|
|
|
|
def initializeUI(self):
|
|
pass
|
|
|