gitee.com/leisunstar/runtime@v0.0.0-20200521203717-5cef3e7b53f9/virtcontainers/qemu_ppc64le.go (about)

     1  // Copyright (c) 2018 IBM
     2  //
     3  // SPDX-License-Identifier: Apache-2.0
     4  //
     5  
     6  package virtcontainers
     7  
     8  import (
     9  	"time"
    10  
    11  	govmmQemu "github.com/intel/govmm/qemu"
    12  	"github.com/kata-containers/runtime/virtcontainers/types"
    13  	"github.com/sirupsen/logrus"
    14  )
    15  
    16  type qemuPPC64le struct {
    17  	// inherit from qemuArchBase, overwrite methods if needed
    18  	qemuArchBase
    19  }
    20  
    21  const defaultQemuPath = "/usr/bin/qemu-system-ppc64le"
    22  
    23  const defaultQemuMachineType = QemuPseries
    24  
    25  const defaultQemuMachineOptions = "accel=kvm,usb=off,cap-cfpc=broken,cap-sbbc=broken,cap-ibs=broken,cap-large-decr=off"
    26  
    27  const defaultMemMaxPPC64le = 32256 // Restrict MemMax to 32Gb on PPC64le
    28  
    29  const qmpMigrationWaitTimeout = 5 * time.Second
    30  
    31  var qemuPaths = map[string]string{
    32  	QemuPseries: defaultQemuPath,
    33  }
    34  
    35  var kernelParams = []Param{
    36  	{"tsc", "reliable"},
    37  	{"no_timer_check", ""},
    38  	{"rcupdate.rcu_expedited", "1"},
    39  	{"noreplace-smp", ""},
    40  	{"reboot", "k"},
    41  	{"console", "hvc0"},
    42  	{"console", "hvc1"},
    43  	{"cryptomgr.notests", ""},
    44  	{"net.ifnames", "0"},
    45  }
    46  
    47  var supportedQemuMachines = []govmmQemu.Machine{
    48  	{
    49  		Type:    QemuPseries,
    50  		Options: defaultQemuMachineOptions,
    51  	},
    52  }
    53  
    54  // Logger returns a logrus logger appropriate for logging qemu messages
    55  func (q *qemuPPC64le) Logger() *logrus.Entry {
    56  	return virtLog.WithField("subsystem", "qemu")
    57  }
    58  
    59  // MaxQemuVCPUs returns the maximum number of vCPUs supported
    60  func MaxQemuVCPUs() uint32 {
    61  	return uint32(128)
    62  }
    63  
    64  func newQemuArch(config HypervisorConfig) qemuArch {
    65  	machineType := config.HypervisorMachineType
    66  	if machineType == "" {
    67  		machineType = defaultQemuMachineType
    68  	}
    69  
    70  	q := &qemuPPC64le{
    71  		qemuArchBase{
    72  			machineType:           machineType,
    73  			memoryOffset:          config.MemOffset,
    74  			qemuPaths:             qemuPaths,
    75  			supportedQemuMachines: supportedQemuMachines,
    76  			kernelParamsNonDebug:  kernelParamsNonDebug,
    77  			kernelParamsDebug:     kernelParamsDebug,
    78  			kernelParams:          kernelParams,
    79  		},
    80  	}
    81  
    82  	q.handleImagePath(config)
    83  
    84  	q.memoryOffset = config.MemOffset
    85  
    86  	return q
    87  }
    88  
    89  func (q *qemuPPC64le) capabilities() types.Capabilities {
    90  	var caps types.Capabilities
    91  
    92  	// pseries machine type supports hotplugging drives
    93  	if q.machineType == QemuPseries {
    94  		caps.SetBlockDeviceHotplugSupport()
    95  	}
    96  
    97  	caps.SetMultiQueueSupport()
    98  	caps.SetFsSharingSupport()
    99  
   100  	return caps
   101  }
   102  
   103  func (q *qemuPPC64le) bridges(number uint32) {
   104  	q.Bridges = genericBridges(number, q.machineType)
   105  }
   106  
   107  func (q *qemuPPC64le) cpuModel() string {
   108  	cpuModel := defaultCPUModel
   109  
   110  	return cpuModel
   111  }
   112  
   113  func (q *qemuPPC64le) memoryTopology(memoryMb, hostMemoryMb uint64, slots uint8) govmmQemu.Memory {
   114  
   115  	if (qemuMajorVersion > 2) || (qemuMajorVersion == 2 && qemuMinorVersion >= 10) {
   116  		q.Logger().Debug("Aligning maxmem to multiples of 256MB. Assumption: Kernel Version >= 4.11")
   117  		hostMemoryMb -= (hostMemoryMb % 256)
   118  	} else {
   119  		q.Logger().Debug("Restricting maxmem to 32GB as Qemu Version < 2.10, Assumption: Kernel Version >= 4.11")
   120  		hostMemoryMb = defaultMemMaxPPC64le
   121  	}
   122  
   123  	return genericMemoryTopology(memoryMb, hostMemoryMb, slots, q.memoryOffset)
   124  }
   125  
   126  // appendBridges appends to devices the given bridges
   127  func (q *qemuPPC64le) appendBridges(devices []govmmQemu.Device) []govmmQemu.Device {
   128  	return genericAppendBridges(devices, q.Bridges, q.machineType)
   129  }