Class: Yast::ArchClass

Inherits:
Module
  • Object
show all
Defined in:
library/general/src/modules/Arch.rb

Instance Method Summary collapse

Instance Method Details

#aarch64Object

true for all aarch64 (ARM64) architectures


168
169
170
# File 'library/general/src/modules/Arch.rb', line 168

def aarch64
  architecture == "aarch64"
end

#alphaObject

true for all alpha architectures


126
127
128
# File 'library/general/src/modules/Arch.rb', line 126

def alpha
  architecture == "alpha"
end

#arch_shortString

Returns general architecture type (one of sparc, ppc, s390, i386, alpha, ia64, x86_64, arm, aarch64)

Returns:


175
176
177
178
179
180
181
182
183
184
185
# File 'library/general/src/modules/Arch.rb', line 175

def arch_short
  if sparc
    "sparc"
  elsif ppc
    "ppc"
  elsif s390
    "s390"
  else
    architecture
  end
end

#architectureString

Returns full architecture type (one of i386, sparc, sparc64, ppc, ppc64, alpha, s390_32, s390_64, ia64, x86_64, arm, aarch64)

Returns:


69
70
71
72
73
74
75
76
# File 'library/general/src/modules/Arch.rb', line 69

def architecture
  if @_architecture.nil?
    @_architecture = Convert.to_string(
      SCR.Read(path(".probe.architecture"))
    )
  end
  @_architecture
end

#armObject

true for all 32-bit ARM architectures


163
164
165
# File 'library/general/src/modules/Arch.rb', line 163

def arm
  architecture == "arm"
end

#board_chrpObject

true for all "CHRP" ppc boards


288
289
290
# File 'library/general/src/modules/Arch.rb', line 288

def board_chrp
  ppc && board_compatible == "CHRP"
end

#board_compatibleObject


general system board types (initialized in constructor)


190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
# File 'library/general/src/modules/Arch.rb', line 190

def board_compatible
  if @_board_compatible.nil?
    @_checkgeneration = ""
    systemProbe = Convert.convert(
      SCR.Read(path(".probe.system")),
      from: "any",
      to:   "list <map>"
    )
    systemProbe = [] if systemProbe.nil?

    Builtins.foreach(systemProbe) do |entry|
      checksys = Ops.get_string(entry, "system", "")
      @_checkgeneration = Ops.get_string(entry, "generation", "")
      @_board_compatible = checksys if checksys != ""
    end
    Builtins.y2milestone("_board_compatible '%1' \n", @_board_compatible)
    @_board_compatible = "wintel" if i386 || x86_64    # hwinfo expects CHRP/PReP/iSeries/MacRISC*/PowerNV in /proc/cpuinfo
    # there is no standard for the board identification
    # Cell and Maple based boards have no CHRP in /proc/cpuinfo
    # Pegasos and Cell do have CHRP in /proc/cpuinfo, but Pegasos2 should no be handled as CHRP
    # Efika is handled like Pegasos for the time being


    if ppc && (@_board_compatible.nil? || @_board_compatible == "CHRP")
      device_type = Convert.to_map(
        SCR.Execute(
          path(".target.bash_output"),
          "/usr/bin/echo -n `/usr/bin/cat /proc/device-tree/device_type`",
          {}
        )
      )
      model = Convert.to_map(
        SCR.Execute(
          path(".target.bash_output"),
          "/usr/bin/echo -n `/usr/bin/cat /proc/device-tree/model`",
          {}
        )
      )
      board = Ops.get_string(model, "stdout", "")
      Builtins.y2milestone(
        "model %1 , device_type %2\n",
        model,
        device_type
      )      # catch remaining IBM boards

      if Builtins.issubstring(
        Ops.get_string(device_type, "stdout", ""),
        "chrp"
      )
        @_board_compatible = "CHRP"
      end      # Maple has its own way of pretenting OF1275 compliance

      @_board_compatible = "CHRP" if ["Momentum,Maple-D", "Momentum,Maple-L", "Momentum,Maple"].include?(board)      # Pegasos has CHRP in /proc/cpuinfo and 'chrp' in /proc/device-tree/device_type

      if board == "Pegasos2" ||
          Builtins.issubstring(
            Builtins.tolower(Ops.get_string(device_type, "stdout", "")),
            "pegasos2"
          )
        @_board_compatible = "Pegasos"
      end      # Efika has CHRP in /proc/cpuinfo and 'efika' in /proc/device-tree/device_type

      if Builtins.issubstring(Builtins.tolower(board), "efika") ||
          Builtins.issubstring(
            Builtins.tolower(Ops.get_string(device_type, "stdout", "")),
            "efika"
          )
        @_board_compatible = "Pegasos"
      end
    end    # avoid future re-probing if probing failed
    # also avoid passing nil outside the module

    @_board_compatible = "" if fun_ref(method(:board_compatible), "string ()").nil?
  end
  @_board_compatible
end

#board_iseriesObject

true for all "iSeries" ppc boards


299
300
301
# File 'library/general/src/modules/Arch.rb', line 299

def board_iseries
  ppc && board_compatible == "iSeries"
end

#board_macObject

true for all PPC "MacRISC" boards


268
269
270
271
272
273
# File 'library/general/src/modules/Arch.rb', line 268

def board_mac
  ppc &&
    (board_compatible == "MacRISC" || board_compatible == "MacRISC2" ||
      board_compatible == "MacRISC3" ||
      board_compatible == "MacRISC4")
end

#board_mac_newObject

true for all "NewWorld" PowerMacs


276
277
278
279
# File 'library/general/src/modules/Arch.rb', line 276

def board_mac_new  # board_mac calls board_compatible which initializes _checkgeneration

  board_mac && @_checkgeneration == "NewWorld"
end

#board_mac_oldObject

true for all "OldWorld" powermacs


282
283
284
285
# File 'library/general/src/modules/Arch.rb', line 282

def board_mac_old  # board_mac calls board_compatible which initializes _checkgeneration

  board_mac && @_checkgeneration == "OldWorld"
end

#board_pegasosObject

true for all "Pegasos" and "Efika" ppc boards


309
310
311
# File 'library/general/src/modules/Arch.rb', line 309

def board_pegasos
  ppc && board_compatible == "Pegasos"
end

#board_powernvObject

true for all baremetal Power8 systems https://github.com/open-power/docs


294
295
296
# File 'library/general/src/modules/Arch.rb', line 294

def board_powernv
  ppc && board_compatible == "PowerNV"
end

#board_prepObject

true for all "PReP" ppc boards


304
305
306
# File 'library/general/src/modules/Arch.rb', line 304

def board_prep
  ppc && board_compatible == "PReP"
end

#board_wintelObject

true for all "Windows/Intel" compliant boards (x86 based)


314
315
316
# File 'library/general/src/modules/Arch.rb', line 314

def board_wintel
  board_compatible == "wintel"
end

#has_pcmciaObject

true if the system supports PCMCIA But modern notebook computers do not have it. See also Bugzilla #151813#c10

Returns:

  • true if the system supports PCMCIA

See Also:


325
326
327
328
# File 'library/general/src/modules/Arch.rb', line 325

def has_pcmcia
  @_has_pcmcia = Convert.to_boolean(SCR.Read(path(".probe.has_pcmcia"))) if @_has_pcmcia.nil?
  @_has_pcmcia
end

#has_smpObject

true if running on multiprocessor board. This only reflects the board, not the actual number of CPUs or the running kernel!

Returns:

  • true if running on multiprocessor board


474
475
476
477
478
479
480
481
# File 'library/general/src/modules/Arch.rb', line 474

def has_smp
  @_has_smp = Convert.to_boolean(SCR.Read(path(".probe.has_smp"))) if @_has_smp.nil?
  if alpha    # get smp for alpha from /etc/install.inf

    setSMP(SCR.Read(path(".etc.install_inf.SMP")) == "1")
  end
  @_has_smp
end

#i386Object

true for all x86 compatible architectures


79
80
81
# File 'library/general/src/modules/Arch.rb', line 79

def i386
  architecture == "i386"
end

#ia64Object

Deprecated.

Itanium is no longer supported

true for all IA64 (itanium) architectures


153
154
155
# File 'library/general/src/modules/Arch.rb', line 153

def ia64
  architecture == "ia64"
end

#is_kvmObject

true if KVM is running

Returns:

  • true if we are running on KVM hypervisor


429
430
431
432
433
434
435
436
437
438
439
# File 'library/general/src/modules/Arch.rb', line 429

def is_kvm
  if @_is_kvm.nil?    # KVM hypervisor has /dev/kvm file

    stat = Convert.to_map(SCR.Read(path(".target.stat"), "/dev/kvm"))
    Builtins.y2milestone("stat /dev/kvm: %1", stat)

    @_is_kvm = Ops.greater_than(Builtins.size(stat), 0)
  end

  @_is_kvm
end

#is_laptopObject

true if the system runs on laptop

Returns:

  • if the system is a laptop


333
334
335
336
337
338
339
340
341
342
343
344
# File 'library/general/src/modules/Arch.rb', line 333

def is_laptop
  if @_is_laptop.nil?
    system = Convert.convert(
      SCR.Read(path(".probe.system")),
      from: "any",
      to:   "list <map>"
    )
    formfactor = Ops.get_string(system, [0, "formfactor"], "")
    @_is_laptop = formfactor == "laptop"
  end
  @_is_laptop
end

#is_umlObject

Deprecated.

true if UML

Returns:

  • true if the system is UML


352
353
354
355
# File 'library/general/src/modules/Arch.rb', line 352

def is_uml
  @_is_uml = Convert.to_boolean(SCR.Read(path(".probe.is_uml"))) if @_is_uml.nil?
  @_is_uml
end

#is_wslBoolean

Determines whether the system is running on WSL

Returns:

  • (Boolean)

    true if runs on WSL; false otherwise


500
501
502
# File 'library/general/src/modules/Arch.rb', line 500

def is_wsl
  SCR.Read(path(".target.string"), "/proc/sys/kernel/osrelease").to_s.include?("-Microsoft")
end

#is_xenObject

true if Xen kernel is running (dom0 or domU)

Returns:

  • true if the Xen kernel is running


361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
# File 'library/general/src/modules/Arch.rb', line 361

def is_xen
  if @_is_xen.nil?    # XEN kernel has /proc/xen directory

    stat = Convert.to_map(SCR.Read(path(".target.stat"), "/proc/xen"))
    Builtins.y2milestone("stat /proc/xen: %1", stat)

    @_is_xen = Ops.greater_than(Builtins.size(stat), 0)

    if @_is_xen
      Builtins.y2milestone("/proc/xen exists")

      # check also the running kernel
      # a FV machine has also /proc/xen, but the kernel is kernel-default
      out = Convert.to_map(
        SCR.Execute(path(".target.bash_output"), "/usr/bin/uname -r", {})
      )

      kernel_ver = Ops.get_string(out, "stdout", "")
      l = Builtins.splitstring(kernel_ver, "\n")
      kernel_ver = Ops.get(l, 0, "")
      Builtins.y2milestone("Kernel version: %1", kernel_ver)

      if !Builtins.regexpmatch(kernel_ver, "-xen$") &&
          !Builtins.regexpmatch(kernel_ver, "-xenpae$")        # kernel default is running

        @_is_xen = false
      end

      Builtins.y2milestone("kernel-xen is running: %1", @_is_xen)
    end
  end

  @_is_xen
end

#is_xen0Object

true if dom0 Xen kernel is running

Returns:

  • true if the Xen kernel is running in dom0

See Also:


400
401
402
403
404
405
406
407
408
409
410
411
412
# File 'library/general/src/modules/Arch.rb', line 400

def is_xen0
  if @_is_xen0.nil?    # dom0 Xen kernel has /proc/xen/xsd_port file

    stat = Convert.to_map(
      SCR.Read(path(".target.stat"), "/proc/xen/xsd_port")
    )
    Builtins.y2milestone("stat /proc/xen/xsd_port: %1", stat)

    @_is_xen0 = Ops.greater_than(Builtins.size(stat), 0)
  end

  @_is_xen0
end

#is_xenUObject

true if domU Xen kernel is running

Returns:

  • true if the Xen kernel is running in another domain than dom0

See Also:


419
420
421
# File 'library/general/src/modules/Arch.rb', line 419

def is_xenU
  is_xen && !is_xen0
end

#is_zkvmObject

zKVM means KVM on IBM System z true if zKVM is running

Returns:

  • true if we are running on zKVM hypervisor


448
449
450
451
452
453
454
455
# File 'library/general/src/modules/Arch.rb', line 448

def is_zkvm
  if @_is_zkvm.nil?    # using different check than on x86 as recommended by IBM

    @_is_zkvm = s390 && Yast::WFM.Execute(path(".local.bash"), "/usr/bin/egrep 'Control Program: KVM' /proc/sysinfo") == 0
  end

  @_is_zkvm
end

#mainObject


33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
# File 'library/general/src/modules/Arch.rb', line 33

def main  # local variables


  @_architecture = nil

  @_board_compatible = nil

  @_checkgeneration = ""

  @_has_pcmcia = nil

  @_is_laptop = nil

  @_is_uml = nil

  @_has_smp = nil

  # Xen domain (dom0 or domU)
  @_is_xen = nil

  # Xen dom0
  @_is_xen0 = nil

  # KVM
  @_is_kvm = nil

  # zKVM
  @_is_zkvm = nil
end

#ppcObject

true for all ppc architectures (32 or 64 bit)

See Also:


121
122
123
# File 'library/general/src/modules/Arch.rb', line 121

def ppc
  ppc32 || ppc64
end

#ppc32Object

true for all 32bit ppc architectures

See Also:


107
108
109
# File 'library/general/src/modules/Arch.rb', line 107

def ppc32
  architecture == "ppc"
end

#ppc64Object

true for all 64bit ppc architectures

See Also:


114
115
116
# File 'library/general/src/modules/Arch.rb', line 114

def ppc64
  architecture == "ppc64"
end

#s390Object

true for all S/390 architectures (32 or 64 bit)

See Also:


147
148
149
# File 'library/general/src/modules/Arch.rb', line 147

def s390
  s390_32 || s390_64
end

#s390_32Object

true for all 32bit S/390 architectures

See Also:


133
134
135
# File 'library/general/src/modules/Arch.rb', line 133

def s390_32
  architecture == "s390_32"
end

#s390_64Object

true for all 64bit S/390 architectures

See Also:


140
141
142
# File 'library/general/src/modules/Arch.rb', line 140

def s390_64
  architecture == "s390_64"
end

#setSMP(is_smp) ⇒ Object

Set "Arch::has_smp ()". Since Alpha doesn't reliably probe smp, 'has_smp' must be set later with this function.

Examples:

setSMP(true);

Parameters:

  • is_smp (Boolean)

    true if has_smp should be true


464
465
466
467
468
# File 'library/general/src/modules/Arch.rb', line 464

def setSMP(is_smp)
  @_has_smp = is_smp

  nil
end

#sparcObject

true for all sparc architectures (32 or 64 bit)

See Also:


100
101
102
# File 'library/general/src/modules/Arch.rb', line 100

def sparc
  sparc32 || sparc64
end

#sparc32Object

true for all 32bit sparc architectures

See Also:


86
87
88
# File 'library/general/src/modules/Arch.rb', line 86

def sparc32
  architecture == "sparc"
end

#sparc64Object

true for all 64bit sparc architectures

See Also:


93
94
95
# File 'library/general/src/modules/Arch.rb', line 93

def sparc64
  architecture == "sparc64"
end

#x11_setup_neededObject

run X11 configuration after inital boot this is false in case of: installation on iSeries, installation on S390

Returns:

  • true when the X11 configuration is needed after inital boot

See Also:

  • Yast::ArchClass#Installation#Installation::x11_setup_needed

490
491
492
493
494
495
# File 'library/general/src/modules/Arch.rb', line 490

def x11_setup_needed  # disable X11 setup after initial boot

  return false if board_iseries || s390

  true
end

#x86_64Object

true for all x86-64 (AMD Hammer) architectures


158
159
160
# File 'library/general/src/modules/Arch.rb', line 158

def x86_64
  architecture == "x86_64"
end