Kdump for xen

package/yast2-kdump.changes

@@ -1,3 +1,9 @@
+-------------------------------------------------------------------
+Wed Mar 29 14:25:05 UTC 2017 - jreidinger@suse.com
+
+- fix dumping kernel with Xen hypervisor (bsc#1014136)
+- 3.1.43
+
 -------------------------------------------------------------------
 Thu Sep 22 15:20:08 CEST 2016 - schubi@suse.de
 

package/yast2-kdump.spec

@@ -17,7 +17,7 @@
 
 
 Name:           yast2-kdump
-Version:        3.1.42
+Version:        3.1.43
 Release:        0
 Summary:        Configuration of kdump
 License:        GPL-2.0

src/autoyast-rnc/kdump.rnc

@@ -6,11 +6,14 @@ namespace config = "http://www.suse.com/1.0/configns"
 kdump =
   element kdump {
      (kdump_crash_kernel_value | kdump_crash_kernel_list)? &
+    # parameter specify crashkernel value for xen hypervisor
+     kdump_crash_xen_value? &
      kdump_add_crash_kernel? &
      kdump_general?
 }
 
 kdump_crash_kernel_value = element crash_kernel { text }
+kdump_crash_xen_kernel_value = element crash_xen_kernel { text }
 kdump_crash_kernel_list = element crash_kernel {
      LIST,
      kdump_crash_kernel_entry+

src/modules/Kdump.rb

@@ -106,6 +106,10 @@ def reset
       # array values of kernel parameter
       @crashkernel_param_values = []
 
+      # array values of kernel parameter for Xen hypervisor
+      # see @crashkernel_param_values for details
+      @crashkernel_xen_param_values = []
+
       # Boolean option indicates add kernel param
       # "crashkernel"
       #
@@ -270,6 +274,7 @@ def checkPassword
     def ReadKdumpKernelParam
       result = Bootloader.kernel_param(:common, "crashkernel")
       result = Bootloader.kernel_param(:xen_guest, "crashkernel") if result == :missing
+      xen_result = Bootloader.kernel_param(:xen_host, "crashkernel")
       # result could be [String,Array,:missing,:present]
       # String   - the value of the only occurrence
       # Array    - the values of the multiple occurrences
@@ -295,6 +300,14 @@ def ReadKdumpKernelParam
         @allocated_memory = get_allocated_memory(@crashkernel_param_values)
       end
 
+      if xen_result == :missing || xen_result == :present
+        @crashkernel_xen_param_values = xen_result
+      else
+        # Let's make sure it's an array
+        # filtering nils and empty entries bnc#991140
+        @crashkernel_xen_param_values = Array(xen_result).compact.reject(&:empty?)
+      end
+
       true
     end
 
@@ -453,14 +466,18 @@ def WriteKdumpBootParameter
         if Mode.autoinst || Mode.autoupgrade
           # Use the value(s) read by import
           crash_values = @crashkernel_param_values
+          crash_xen_values = @crashkernel_xen_param_values
           # Always write the value
           skip_crash_values = false
         else
           # Calculate the param values based on @allocated_memory
           crash_values = crash_kernel_values
+          crash_xen_values = crash_xen_kernel_values
           remove_offsets!(crash_values) if Mode.update
+          remove_offsets!(crash_xen_values) if Mode.update
           # Skip writing of param if it's already set to the desired values
           skip_crash_values = @crashkernel_param && @crashkernel_param_values == crash_values
+          skip_crash_values &&= @crashkernel_xen_param_values && @crashkernel_xen_param_values == crash_xen_values
         end
 
         if skip_crash_values
@@ -469,16 +486,21 @@ def WriteKdumpBootParameter
           Service.Restart(KDUMP_SERVICE_NAME) if Service.active?(KDUMP_SERVICE_NAME)
         else
           Bootloader.modify_kernel_params(:common, :xen_guest, :recovery, "crashkernel" => crash_values)
+          Bootloader.modify_kernel_params(:xen_host, "crashkernel" => crash_xen_values)
           # do mass write in installation to speed up, so skip this one
           if !Stage.initial
             old_progress = Progress.set(false)
             Bootloader.Write
             Progress.set(old_progress)
           end
           Builtins.y2milestone(
-            "[kdump] (WriteKdumpBootParameter) adding chrashkernel options with values: %1",
+            "[kdump] (WriteKdumpBootParameter) adding crashkernel options with values: %1",
             crash_values
           )
+          Builtins.y2milestone(
+            "[kdump] (WriteKdumpBootParameter) adding xen crashkernel options with values: %1",
+            crash_xen_values
+          )
           reboot_needed = true
           Service.Enable(KDUMP_SERVICE_NAME)
         end
@@ -487,6 +509,7 @@ def WriteKdumpBootParameter
         if @crashkernel_param
           #delete crashkernel parameter from bootloader
           Bootloader.modify_kernel_params(:common, :xen_guest, :recovery, "crashkernel" => :missing)
+          Bootloader.modify_kernel_params(:common, :xen_host, :recovery, "crashkernel" => :missing)
           if !Stage.initial
             old_progress = Progress.set(false)
             Bootloader.Write
@@ -920,8 +943,11 @@ def filterExport(settings)
     def Export
       crash_kernel = crash_kernel_values
       crash_kernel = crash_kernel[0] if crash_kernel.size == 1
+      crash_xen_kernel = crash_kernel_values
+      crash_xen_kernel = crash_xen_kernel[0] if crash_xen_kernel.size == 1
       out = {
         "crash_kernel"     => crash_kernel,
+        "crash_xen_kernel" => crash_xen_kernel,
         "add_crash_kernel" => @add_crashkernel_param,
         "general"          => filterExport(@KDUMP_SETTINGS)
       }
@@ -955,6 +981,14 @@ def Import(settings)
         # Make sure it's an array
         @crashkernel_param_values = Array(crash_kernel_values)
       end
+
+      if Builtins.haskey(settings, "crash_xen_kernel")
+        # Make sure it's an array
+        @crashkernel_xen_param_values = Array(settings.fetch("crash_xen_kernel", ""))
+      else
+        @crashkernel_xen_param_values = Array(crash_xen_kernel_values)
+      end
+
       if settings.has_key?("add_crash_kernel")
         @add_crashkernel_param = settings["add_crash_kernel"]
       else
@@ -1123,6 +1157,31 @@ def crash_kernel_values
       result
     end
 
+    def crash_xen_kernel_values
+      # If the current values include "nasty" things and the user has not
+      # overriden the value of @crashkernel_list_ranges to autorize the
+      # modification.
+      # The old value (ensuring the Array format) will be returned.
+      if @crashkernel_list_ranges
+        return Array(@crashkernel_xen_param_values.dup)
+      end
+
+      result = []
+      high = @allocated_memory[:high]
+      low = @allocated_memory[:low]
+      sum = 0
+      sum += low.to_i if low
+      sum += high.to_i if high
+
+      if sum != 0
+        result << "#{sum}M\\<4G"
+      end
+
+      log.info "built xen crashkernel values are #{result}"
+
+      result
+    end
+
     # Removes offsets from all the crashkernel values
     #
     # Beware: not functional, it modifies the passed argument

test/kdump_test.rb

@@ -421,6 +421,7 @@
 
     context "during autoinstallation" do
       let(:bootlader_kernel_params) { ["73M,high"] }
+      let(:bootlader_xen_kernel_params) { ["73M\\<4G"] }
 
       before do
         allow(Yast::Mode).to receive(:autoinst).and_return true
@@ -430,12 +431,15 @@
       end
 
       context "if kdump is requested and a value for crashkernel is supplied" do
-        let(:profile) { { "add_crash_kernel" => true, "crash_kernel" => "the_value" } }
+        let(:profile) { { "add_crash_kernel" => true, "crash_kernel" => "the_value", "crash_xen_kernel" => "xen_value" } }
 
         it "writes the crashkernel value to the bootloader and enables the service" do
           expect(Yast::Bootloader)
             .to receive(:modify_kernel_params)
             .with(:common, :xen_guest, :recovery, "crashkernel" => ["the_value"])
+          expect(Yast::Bootloader)
+            .to receive(:modify_kernel_params)
+            .with(:xen_host, "crashkernel" => ["xen_value"])
           expect(Yast::Bootloader).to receive(:Write)
           expect(Yast::Service).to receive(:Enable).with("kdump")
 
@@ -444,12 +448,15 @@
       end
 
       context "if kdump is requested but empty value for crashkernel is supplied" do
-        let(:profile) { { "add_crash_kernel" => true, "crash_kernel" => [] } }
+        let(:profile) { { "add_crash_kernel" => true, "crash_kernel" => [], "crash_xen_kernel" => [] } }
 
         it "writes an empty crashkernel in the bootloader and enables the service" do
           expect(Yast::Bootloader)
             .to receive(:modify_kernel_params)
             .with(:common, :xen_guest, :recovery, "crashkernel" => [])
+          expect(Yast::Bootloader)
+            .to receive(:modify_kernel_params)
+            .with(:xen_host, "crashkernel" => [])
           expect(Yast::Bootloader).to receive(:Write)
           expect(Yast::Service).to receive(:Enable).with("kdump")
 
@@ -464,6 +471,9 @@
           expect(Yast::Bootloader)
             .to receive(:modify_kernel_params)
             .with(:common, :xen_guest, :recovery, "crashkernel" => bootlader_kernel_params)
+          expect(Yast::Bootloader)
+            .to receive(:modify_kernel_params)
+            .with(:xen_host, "crashkernel" => bootlader_xen_kernel_params)
           expect(Yast::Bootloader).to receive(:Write)
           expect(Yast::Service).to receive(:Enable).with("kdump")
 
@@ -486,12 +496,15 @@
       end
 
       context "if kdump crashkernel contains an offset" do
-        let(:profile) { { "add_crash_kernel" => true, "crash_kernel" => "72M@128" } }
+        let(:profile) { { "add_crash_kernel" => true, "crash_kernel" => "72M@128", "crash_xen_kernel" => "72M@128"} }
 
         it "writes the crashkernel value without removing the offset" do
           expect(Yast::Bootloader)
             .to receive(:modify_kernel_params)
             .with(:common, :xen_guest, :recovery, "crashkernel" => ["72M@128"])
+          expect(Yast::Bootloader)
+            .to receive(:modify_kernel_params)
+            .with(:xen_host, "crashkernel" => ["72M@128"])
           expect(Yast::Bootloader).to receive(:Write)
           expect(Yast::Service).to receive(:Enable).with("kdump")
 
@@ -502,6 +515,7 @@
 
     context "during autoupgrade" do
       let(:bootlader_kernel_params) { ["75M,high"] }
+      let(:bootlader_xen_kernel_params) { ["75M\\<4G"] }
 
       before do
         allow(Yast::Mode).to receive(:autoupgrade).and_return true
@@ -511,12 +525,15 @@
       end
 
       context "if kdump is requested and a value for crashkernel is supplied" do
-        let(:profile) { { "add_crash_kernel" => true, "crash_kernel" => "the_value" } }
+        let(:profile) { { "add_crash_kernel" => true, "crash_kernel" => "the_value", "crash_xen_kernel" => "xen_value" } }
 
         it "writes the crashkernel value to the bootloader and enables the service" do
           expect(Yast::Bootloader)
             .to receive(:modify_kernel_params)
             .with(:common, :xen_guest, :recovery, "crashkernel" => ["the_value"])
+          expect(Yast::Bootloader)
+            .to receive(:modify_kernel_params)
+            .with(:xen_host, "crashkernel" => ["xen_value"])
           expect(Yast::Bootloader).to receive(:Write)
           expect(Yast::Service).to receive(:Enable).with("kdump")
 
@@ -525,12 +542,15 @@
       end
 
       context "if kdump is requested but an empty value for crashkernel is supplied" do
-        let(:profile) { { "add_crash_kernel" => true, "crash_kernel" => [] } }
+        let(:profile) { { "add_crash_kernel" => true, "crash_kernel" => [], "crash_xen_kernel" => [] } }
 
         it "writes an empty crashkernel in the bootloader and enables the service" do
           expect(Yast::Bootloader)
             .to receive(:modify_kernel_params)
             .with(:common, :xen_guest, :recovery, "crashkernel" => [])
+          expect(Yast::Bootloader)
+            .to receive(:modify_kernel_params)
+            .with(:xen_host, "crashkernel" => [])
           expect(Yast::Bootloader).to receive(:Write)
           expect(Yast::Service).to receive(:Enable).with("kdump")
 
@@ -545,6 +565,9 @@
           expect(Yast::Bootloader)
             .to receive(:modify_kernel_params)
             .with(:common, :xen_guest, :recovery, "crashkernel" => bootlader_kernel_params)
+          expect(Yast::Bootloader)
+            .to receive(:modify_kernel_params)
+            .with(:xen_host, "crashkernel" => bootlader_xen_kernel_params)
           expect(Yast::Bootloader).to receive(:Write)
           expect(Yast::Service).to receive(:Enable).with("kdump")
 
@@ -567,12 +590,15 @@
       end
 
       context "if kdump crashkernel contains an offset" do
-        let(:profile) { { "add_crash_kernel" => true, "crash_kernel" => "72M@128" } }
+        let(:profile) { { "add_crash_kernel" => true, "crash_kernel" => "72M@128", "crash_xen_kernel" => "72@128" } }
 
         it "writes the crashkernel value without removing the offset" do
           expect(Yast::Bootloader)
             .to receive(:modify_kernel_params)
             .with(:common, :xen_guest, :recovery, "crashkernel" => ["72M@128"])
+          expect(Yast::Bootloader)
+            .to receive(:modify_kernel_params)
+            .with(:xen_host, "crashkernel" => ["72M@128"])
           expect(Yast::Bootloader).to receive(:Write)
           expect(Yast::Service).to receive(:Enable).with("kdump")
 
@@ -596,6 +622,9 @@
           expect(Yast::Bootloader)
             .to receive(:modify_kernel_params)
             .with(:common, :xen_guest, :recovery, "crashkernel" => ["128M"])
+          expect(Yast::Bootloader)
+            .to receive(:modify_kernel_params)
+            .with(:common, :xen_guest, :recovery, "crashkernel" => ["128M\\<4G"])
           expect(Yast::Bootloader).to receive(:Write)
           expect(Yast::Service).to receive(:Enable).with("kdump")
 
@@ -618,6 +647,9 @@
           expect(Yast::Bootloader)
           .to receive(:modify_kernel_params)
           .with(:common, :xen_guest, :recovery, "crashkernel" => :missing)
+          expect(Yast::Bootloader)
+          .to receive(:modify_kernel_params)
+          .with(:xen_host, "crashkernel" => :missing)
           expect(Yast::Bootloader).to receive(:Write)
           expect(Yast::Service).to receive(:Disable).with("kdump")
 
@@ -633,6 +665,9 @@
           expect(Yast::Bootloader)
           .to receive(:modify_kernel_params)
           .with(:common, :xen_guest, :recovery, "crashkernel" => ["64M"])
+          expect(Yast::Bootloader)
+          .to receive(:modify_kernel_params)
+          .with(:xen_host, "crashkernel" => ["64M\\<4G"])
           expect(Yast::Bootloader).to receive(:Write)
           expect(Yast::Service).to receive(:Enable).with("kdump")
 
@@ -666,6 +701,9 @@
             expect(Yast::Bootloader)
               .to receive(:modify_kernel_params)
               .with(:common, :xen_guest, :recovery, {"crashkernel" => ["64M"]})
+            expect(Yast::Bootloader)
+              .to receive(:modify_kernel_params)
+              .with(:xen_host, "crashkernel" => ["64M\\<4G"])
             Yast::Kdump.WriteKdumpBootParameter
           end
         end
@@ -699,6 +737,9 @@
           expect(Yast::Bootloader)
             .to receive(:modify_kernel_params)
             .with(:common, :xen_guest, :recovery, {"crashkernel" => ["64M"]})
+          expect(Yast::Bootloader)
+            .to receive(:modify_kernel_params)
+            .with(:xen_host, "crashkernel" => ["64M\\<4G"])
           Yast::Kdump.WriteKdumpBootParameter
         end
       end
@@ -710,6 +751,9 @@
           expect(Yast::Bootloader)
             .to receive(:modify_kernel_params)
             .with(:common, :xen_guest, :recovery, {"crashkernel" => ["-512M:64M,512M-:128M"]})
+          expect(Yast::Bootloader)
+            .to receive(:modify_kernel_params)
+            .with(:xen_host, {"crashkernel" => ["-512M:64M,512M-:128M"]})
           Yast::Kdump.WriteKdumpBootParameter
         end
       end