1
0
out-of-tree/kernel.go

888 lines
21 KiB
Go
Raw Normal View History

// Copyright 2023 Mikhail Klementev. All rights reserved.
2018-11-17 20:24:09 +00:00
// Use of this source code is governed by a AGPLv3 license
// (or later) that can be found in the LICENSE file.
package main
import (
"errors"
"fmt"
"io/ioutil"
"math"
"math/rand"
"os"
"os/exec"
2023-04-07 20:52:45 +00:00
"os/signal"
"os/user"
"regexp"
"runtime"
"strings"
"time"
2018-11-17 20:24:09 +00:00
2018-11-28 23:53:47 +00:00
"github.com/naoina/toml"
2023-03-18 21:30:07 +00:00
"github.com/rs/zerolog/log"
"code.dumpstack.io/tools/out-of-tree/config"
"code.dumpstack.io/tools/out-of-tree/fs"
2018-11-17 20:24:09 +00:00
)
2023-01-31 07:13:33 +00:00
type KernelCmd struct {
NoDownload bool `help:"do not download qemu image while kernel generation"`
UseHost bool `help:"also use host kernels"`
Force bool `help:"force reinstall kernel"`
NoHeaders bool `help:"do not install kernel headers"`
Shuffle bool `help:"randomize kernels installation order"`
2023-04-05 16:26:26 +00:00
Retries int64 `help:"amount of tries for each kernel" default:"10"`
Update bool `help:"update container"`
2023-01-31 07:13:33 +00:00
2023-03-24 04:20:28 +00:00
List KernelListCmd `cmd:"" help:"list kernels"`
2023-05-10 07:52:44 +00:00
ListRemote KernelListRemoteCmd `cmd:"" help:"list remote kernels"`
2023-03-24 04:20:28 +00:00
Autogen KernelAutogenCmd `cmd:"" help:"generate kernels based on the current config"`
Genall KernelGenallCmd `cmd:"" help:"generate all kernels for distro"`
Install KernelInstallCmd `cmd:"" help:"install specific kernel"`
ConfigRegen KernelConfigRegenCmd `cmd:"" help:"regenerate config"`
2023-01-31 07:13:33 +00:00
}
type KernelListCmd struct{}
func (cmd *KernelListCmd) Run(g *Globals) (err error) {
kcfg, err := config.ReadKernelConfig(g.Config.Kernels)
if err != nil {
log.Debug().Err(err).Msg("read kernel config")
2023-01-31 07:13:33 +00:00
}
2018-11-17 20:24:09 +00:00
if len(kcfg.Kernels) == 0 {
return errors.New("No kernels found")
}
2023-01-31 07:13:33 +00:00
2018-11-17 20:24:09 +00:00
for _, k := range kcfg.Kernels {
fmt.Println(k.DistroType, k.DistroRelease, k.KernelRelease)
}
2023-01-31 07:13:33 +00:00
2018-11-17 20:24:09 +00:00
return
}
2023-05-10 07:52:44 +00:00
type KernelListRemoteCmd struct {
Distro string `required:"" help:"distribution"`
Ver string `required:"" help:"distro version"`
}
func (cmd *KernelListRemoteCmd) Run(kernelCmd *KernelCmd, g *Globals) (err error) {
2023-05-10 07:52:44 +00:00
distroType, err := config.NewDistroType(cmd.Distro)
if err != nil {
return
}
km := config.KernelMask{
DistroType: distroType,
DistroRelease: cmd.Ver,
ReleaseMask: ".*",
}
_, err = genRootfsImage(containerImageInfo{Name: km.DockerName()}, false)
if err != nil {
return
}
err = generateBaseDockerImage(
g.Config.Docker.Registry,
g.Config.Docker.Commands,
km,
kernelCmd.Update,
2023-05-10 07:52:44 +00:00
)
if err != nil {
return
}
pkgs, err := matchPackages(km)
for _, k := range pkgs {
fmt.Println(k)
}
return
}
2023-01-31 07:13:33 +00:00
type KernelAutogenCmd struct {
Max int64 `help:"download kernels from set defined by regex in release_mask, but no more than X for each of release_mask" default:"100500"`
2023-01-31 07:13:33 +00:00
}
2023-01-31 09:05:43 +00:00
func (cmd KernelAutogenCmd) Run(kernelCmd *KernelCmd, g *Globals) (err error) {
2023-01-31 07:13:33 +00:00
ka, err := config.ReadArtifactConfig(g.WorkDir + "/.out-of-tree.toml")
if err != nil {
return
}
2023-04-07 20:52:45 +00:00
shutdown := false
setSigintHandler(&shutdown)
2023-01-31 07:13:33 +00:00
for _, sk := range ka.SupportedKernels {
if sk.DistroRelease == "" {
err = errors.New("Please set distro_release")
return
}
2023-03-29 17:15:27 +00:00
err = generateKernels(sk,
g.Config.Docker.Registry,
g.Config.Docker.Commands,
cmd.Max, kernelCmd.Retries,
2023-03-29 17:15:27 +00:00
!kernelCmd.NoDownload,
kernelCmd.Force,
!kernelCmd.NoHeaders,
kernelCmd.Shuffle,
kernelCmd.Update,
2023-04-07 20:52:45 +00:00
&shutdown,
2023-03-29 17:15:27 +00:00
)
2023-01-31 07:13:33 +00:00
if err != nil {
return
}
2023-04-07 20:52:45 +00:00
if shutdown {
break
}
2023-01-31 07:13:33 +00:00
}
return updateKernelsCfg(kernelCmd.UseHost, !kernelCmd.NoDownload)
}
type KernelGenallCmd struct {
Distro string `required:"" help:"distribution"`
Ver string `required:"" help:"distro version"`
}
func (cmd *KernelGenallCmd) Run(kernelCmd *KernelCmd, g *Globals) (err error) {
distroType, err := config.NewDistroType(cmd.Distro)
if err != nil {
return
}
2023-04-07 20:52:45 +00:00
shutdown := false
setSigintHandler(&shutdown)
2023-01-31 07:13:33 +00:00
km := config.KernelMask{
DistroType: distroType,
DistroRelease: cmd.Ver,
ReleaseMask: ".*",
}
err = generateKernels(km,
g.Config.Docker.Registry,
g.Config.Docker.Commands,
math.MaxUint32, kernelCmd.Retries,
2023-03-22 18:21:21 +00:00
!kernelCmd.NoDownload,
kernelCmd.Force,
2023-03-29 17:15:27 +00:00
!kernelCmd.NoHeaders,
kernelCmd.Shuffle,
kernelCmd.Update,
2023-04-07 20:52:45 +00:00
&shutdown,
2023-03-22 18:21:21 +00:00
)
if err != nil {
return
}
return updateKernelsCfg(kernelCmd.UseHost, !kernelCmd.NoDownload)
}
type KernelInstallCmd struct {
Distro string `required:"" help:"distribution"`
Ver string `required:"" help:"distro version"`
Kernel string `required:"" help:"kernel release mask"`
}
func (cmd *KernelInstallCmd) Run(kernelCmd *KernelCmd, g *Globals) (err error) {
distroType, err := config.NewDistroType(cmd.Distro)
if err != nil {
return
}
2023-04-07 20:52:45 +00:00
shutdown := false
setSigintHandler(&shutdown)
2023-03-22 18:21:21 +00:00
km := config.KernelMask{
DistroType: distroType,
DistroRelease: cmd.Ver,
ReleaseMask: cmd.Kernel,
}
err = generateKernels(km,
g.Config.Docker.Registry,
g.Config.Docker.Commands,
math.MaxUint32, kernelCmd.Retries,
!kernelCmd.NoDownload,
2023-03-22 18:20:45 +00:00
kernelCmd.Force,
2023-03-29 17:15:27 +00:00
!kernelCmd.NoHeaders,
kernelCmd.Shuffle,
kernelCmd.Update,
2023-04-07 20:52:45 +00:00
&shutdown,
)
2023-01-31 07:13:33 +00:00
if err != nil {
return
}
return updateKernelsCfg(kernelCmd.UseHost, !kernelCmd.NoDownload)
}
2023-03-24 04:20:28 +00:00
type KernelConfigRegenCmd struct{}
func (cmd *KernelConfigRegenCmd) Run(kernelCmd *KernelCmd, g *Globals) (err error) {
return updateKernelsCfg(kernelCmd.UseHost, !kernelCmd.NoDownload)
}
2023-04-05 12:31:46 +00:00
func matchDebImagePkg(container, mask string) (pkgs []string, err error) {
2023-04-05 12:31:46 +00:00
cmd := "apt-cache search --names-only '^linux-image-[0-9\\.\\-]*-generic' | awk '{ print $1 }'"
2023-03-24 04:15:08 +00:00
// FIXME timeout should be in global out-of-tree config
c, err := NewContainer(container, time.Hour)
if err != nil {
return
}
2023-04-07 16:43:56 +00:00
output, err := c.Run(tempDirBase, cmd)
if err != nil {
return
}
2023-03-29 17:15:27 +00:00
r, err := regexp.Compile("linux-image-" + mask)
if err != nil {
return
}
2023-04-05 18:01:04 +00:00
for _, pkg := range strings.Fields(output) {
if r.MatchString(pkg) || strings.Contains(pkg, mask) {
pkgs = append(pkgs, pkg)
}
}
return
}
2023-05-09 14:40:06 +00:00
func matchOracleLinuxPkg(container, mask string) (
pkgs []string, err error) {
cmd := "yum search kernel --showduplicates " +
"| grep '^kernel-[0-9]\\|^kernel-uek-[0-9]' " +
"| grep -v src " +
"| cut -d ' ' -f 1"
// FIXME timeout should be in global out-of-tree config
c, err := NewContainer(container, time.Hour)
if err != nil {
return
}
output, err := c.Run(tempDirBase, cmd)
if err != nil {
return
}
r, err := regexp.Compile("kernel-" + mask)
if err != nil {
return
}
for _, pkg := range strings.Fields(output) {
if r.MatchString(pkg) || strings.Contains(pkg, mask) {
log.Trace().Msg(pkg)
pkgs = append(pkgs, pkg)
}
}
if len(pkgs) == 0 {
log.Warn().Msg("no packages matched")
}
2023-05-09 14:40:06 +00:00
return
}
2023-05-10 07:52:44 +00:00
func matchPackages(km config.KernelMask) (pkgs []string, err error) {
switch km.DistroType {
case config.Ubuntu:
pkgs, err = matchDebImagePkg(km.DockerName(), km.ReleaseMask)
case config.OracleLinux, config.CentOS:
pkgs, err = matchOracleLinuxPkg(km.DockerName(), km.ReleaseMask)
default:
err = fmt.Errorf("%s not yet supported", km.DistroType.String())
}
return
}
func dockerImagePath(sk config.KernelMask) (path string, err error) {
usr, err := user.Current()
if err != nil {
return
}
path = usr.HomeDir + "/.out-of-tree/containers/"
path += sk.DistroType.String() + "/" + sk.DistroRelease
return
}
2019-08-20 18:57:45 +00:00
func vsyscallAvailable() (available bool, err error) {
if runtime.GOOS != "linux" {
// Docker for non-Linux systems is not using the host
// kernel but uses kernel inside a virtual machine, so
// it builds by the Docker team with vsyscall support.
available = true
return
}
2019-08-20 18:57:45 +00:00
buf, err := ioutil.ReadFile("/proc/self/maps")
if err != nil {
return
}
available = strings.Contains(string(buf), "[vsyscall]")
return
}
func generateBaseDockerImage(registry string, commands []config.DockerCommand,
2023-05-10 07:52:44 +00:00
sk config.KernelMask, forceUpdate bool) (err error) {
imagePath, err := dockerImagePath(sk)
if err != nil {
return
}
dockerPath := imagePath + "/Dockerfile"
d := "# BASE\n"
// TODO move as function to container.go
cmd := exec.Command(containerRuntime, "images", "-q", sk.DockerName())
2023-03-22 18:05:13 +00:00
log.Debug().Msgf("run %v", cmd)
2023-03-19 13:14:14 +00:00
2023-01-30 11:15:12 +00:00
rawOutput, err := cmd.CombinedOutput()
if err != nil {
return
}
if fs.PathExists(dockerPath) && string(rawOutput) != "" {
log.Info().Msgf("Base image for %s:%s found",
sk.DistroType.String(), sk.DistroRelease)
2023-05-10 07:52:44 +00:00
if !forceUpdate {
return
} else {
log.Info().Msgf("Update Containerfile")
}
}
log.Info().Msgf("Base image for %s:%s not found, start generating",
2018-12-10 02:39:55 +00:00
sk.DistroType.String(), sk.DistroRelease)
os.MkdirAll(imagePath, os.ModePerm)
d += "FROM "
if registry != "" {
d += registry + "/"
}
d += fmt.Sprintf("%s:%s\n",
strings.ToLower(sk.DistroType.String()),
sk.DistroRelease,
)
for _, c := range commands {
2023-04-05 19:32:31 +00:00
d += "RUN " + c.Command + "\n"
}
switch sk.DistroType {
case config.Ubuntu:
2023-05-10 09:13:05 +00:00
if sk.DistroRelease < "14.04" {
d += "RUN sed -i 's/archive.ubuntu.com/old-releases.ubuntu.com/' /etc/apt/sources.list\n"
}
d += "ENV DEBIAN_FRONTEND=noninteractive\n"
d += "RUN apt-get update\n"
d += "RUN apt-get install -y build-essential libelf-dev\n"
d += "RUN apt-get install -y wget git\n"
2023-04-06 20:53:59 +00:00
// Install a single kernel and headers to ensure all dependencies are cached
if sk.DistroRelease >= "14.04" {
2023-05-10 09:13:05 +00:00
d += "RUN export PKGNAME=$(apt-cache search --names-only '^linux-headers-[0-9\\.\\-]*-generic' | awk '{ print $1 }' | head -n 1); " +
"apt-get install -y $PKGNAME $(echo $PKGNAME | sed 's/headers/image/'); " +
"apt-get remove -y $PKGNAME $(echo $PKGNAME | sed 's/headers/image/')\n"
d += "RUN apt-get install -y libseccomp-dev\n"
}
2019-08-23 06:46:37 +00:00
d += "RUN mkdir -p /lib/modules\n"
2019-08-20 18:57:45 +00:00
case config.CentOS:
2023-05-10 08:04:42 +00:00
var repos []string
switch sk.DistroRelease {
case "6":
repofmt := "[6.%d-%s]\\nbaseurl=https://vault.centos.org/6.%d/%s/$basearch/\\ngpgcheck=0"
for i := 0; i <= 10; i++ {
repos = append(repos, fmt.Sprintf(repofmt, i, "os", i, "os"))
repos = append(repos, fmt.Sprintf(repofmt, i, "updates", i, "updates"))
}
d += "RUN rm /etc/yum.repos.d/*\n"
case "7":
repofmt := "[%s-%s]\\nbaseurl=https://vault.centos.org/%s/%s/$basearch/\\ngpgcheck=0"
for _, ver := range []string{
"7.0.1406", "7.1.1503", "7.2.1511",
"7.3.1611", "7.4.1708", "7.5.1804",
"7.6.1810", "7.7.1908", "7.8.2003",
} {
repos = append(repos, fmt.Sprintf(repofmt, ver, "os", ver, "os"))
repos = append(repos, fmt.Sprintf(repofmt, ver, "updates", ver, "updates"))
}
// FIXME http/gpgcheck=0
repofmt = "[%s-%s]\\nbaseurl=http://mirror.centos.org/centos-7/%s/%s/$basearch/\\ngpgcheck=0"
repos = append(repos, fmt.Sprintf(repofmt, "7.9.2009", "os", "7.9.2009", "os"))
repos = append(repos, fmt.Sprintf(repofmt, "7.9.2009", "updates", "7.9.2009", "updates"))
case "8":
repofmt := "[%s]\\nbaseurl=https://vault.centos.org/%s/BaseOS/$basearch/os/\\ngpgcheck=0"
for _, ver := range []string{
"8.0.1905", "8.1.1911", "8.2.2004",
"8.3.2011", "8.4.2105", "8.5.2111",
2023-04-06 13:38:33 +00:00
} {
2023-05-10 08:04:42 +00:00
repos = append(repos, fmt.Sprintf(repofmt, ver, ver))
2023-04-06 13:38:33 +00:00
}
2023-05-10 08:04:42 +00:00
default:
err = fmt.Errorf("no support for %s %s", sk.DistroType, sk.DistroRelease)
return
}
d += "RUN sed -i 's/enabled=1/enabled=0/' /etc/yum.repos.d/* || true\n"
for _, repo := range repos {
d += fmt.Sprintf("RUN echo -e '%s' >> /etc/yum.repos.d/oot.repo\n", repo)
2019-08-20 18:57:45 +00:00
}
// do not remove old kernels
d += "RUN sed -i 's;installonly_limit=;installonly_limit=100500;' /etc/yum.conf\n"
d += "RUN yum -y update\n"
2020-05-30 14:13:03 +00:00
2019-08-20 18:57:45 +00:00
d += "RUN yum -y groupinstall 'Development Tools'\n"
2020-05-30 12:40:12 +00:00
if sk.DistroRelease < "8" {
d += "RUN yum -y install deltarpm\n"
} else {
2023-04-06 13:38:33 +00:00
d += "RUN yum -y install grub2-tools-minimal " +
2020-05-30 13:42:04 +00:00
"elfutils-libelf-devel\n"
2020-05-30 12:40:12 +00:00
}
2023-04-06 21:56:22 +00:00
2023-04-06 22:37:15 +00:00
var flags string
if sk.DistroRelease >= "8" {
flags = "--noautoremove"
}
2023-04-06 21:56:22 +00:00
// Cache kernel package dependencies
2023-04-06 21:57:47 +00:00
d += "RUN export PKGNAME=$(yum search kernel-devel --showduplicates | grep '^kernel-devel' | cut -d ' ' -f 1 | head -n 1); " +
2023-04-06 21:56:22 +00:00
"yum -y install $PKGNAME $(echo $PKGNAME | sed 's/-devel//'); " +
2023-04-09 17:13:54 +00:00
fmt.Sprintf("yum -y remove $PKGNAME "+
"$(echo $PKGNAME | sed 's/-devel//') "+
"$(echo $PKGNAME | sed 's/-devel/-modules/') "+
"$(echo $PKGNAME | sed 's/-devel/-core/') %s\n", flags)
2023-05-09 14:40:06 +00:00
case config.OracleLinux:
if sk.DistroRelease < "6" {
err = fmt.Errorf("no support for pre-EL6")
return
}
d += "RUN sed -i 's/enabled=0/enabled=1/' /etc/yum.repos.d/*\n"
d += "RUN sed -i 's;installonly_limit=;installonly_limit=100500;' /etc/yum.conf /etc/dnf/dnf.conf || true\n"
d += "RUN yum -y update\n"
d += "RUN yum -y groupinstall 'Development Tools'\n"
2023-05-10 11:20:07 +00:00
packages := "linux-firmware grubby"
2023-05-09 20:16:28 +00:00
if sk.DistroRelease <= "7" {
2023-05-10 11:20:07 +00:00
packages += " libdtrace-ctf"
2023-05-09 20:16:28 +00:00
}
2023-05-10 11:20:07 +00:00
d += fmt.Sprintf("RUN yum -y install %s\n", packages)
default:
2018-12-10 02:45:17 +00:00
err = fmt.Errorf("%s not yet supported", sk.DistroType.String())
return
}
d += "# END BASE\n\n"
err = ioutil.WriteFile(dockerPath, []byte(d), 0644)
if err != nil {
return
}
c, err := NewContainer(sk.DockerName(), time.Hour)
if err != nil {
return
}
2023-03-19 13:14:14 +00:00
output, err := c.Build(imagePath)
if err != nil {
log.Error().Err(err).Msgf("Base image for %s:%s generating error",
sk.DistroType.String(), sk.DistroRelease)
log.Fatal().Msg(output)
return
}
log.Info().Msgf("Base image for %s:%s generating success",
sk.DistroType.String(), sk.DistroRelease)
return
}
2023-03-29 17:15:27 +00:00
func installKernel(sk config.KernelMask, pkgname string, force, headers bool) (err error) {
2023-03-22 18:05:13 +00:00
slog := log.With().
Str("distro_type", sk.DistroType.String()).
Str("distro_release", sk.DistroRelease).
Str("pkg", pkgname).
Logger()
c, err := NewContainer(sk.DockerName(), time.Hour) // TODO conf
if err != nil {
return
}
2023-03-22 18:05:13 +00:00
moddirs, err := ioutil.ReadDir(c.Volumes.LibModules)
if err != nil {
return
}
2023-03-22 18:05:13 +00:00
for _, krel := range moddirs {
if strings.Contains(pkgname, krel.Name()) {
2023-03-22 18:20:45 +00:00
if force {
slog.Info().Msg("Reinstall")
} else {
2023-03-22 18:24:09 +00:00
slog.Info().Msg("Already installed")
2023-03-22 18:20:45 +00:00
return
}
2023-03-22 18:05:13 +00:00
}
}
2023-04-05 16:14:30 +00:00
volumes := c.Volumes
c.Volumes.LibModules = ""
c.Volumes.UsrSrc = ""
c.Volumes.Boot = ""
2023-04-05 16:14:30 +00:00
2023-03-22 18:08:48 +00:00
slog.Debug().Msgf("Installing kernel")
2023-03-22 18:05:13 +00:00
cmd := "true"
2019-08-20 18:57:45 +00:00
switch sk.DistroType {
case config.Ubuntu:
2023-03-29 17:15:27 +00:00
var headerspkg string
if headers {
headerspkg = strings.Replace(pkgname, "image", "headers", -1)
}
cmd += fmt.Sprintf(" && apt-get install -y %s %s", pkgname, headerspkg)
2023-05-10 07:52:44 +00:00
case config.OracleLinux, config.CentOS:
2023-05-09 14:40:06 +00:00
var headerspkg string
if headers {
if strings.Contains(pkgname, "uek") {
headerspkg = strings.Replace(pkgname,
"kernel-uek", "kernel-uek-devel", -1)
} else {
headerspkg = strings.Replace(pkgname,
"kernel", "kernel-devel", -1)
}
}
cmd += fmt.Sprintf(" && yum -y install %s %s", pkgname, headerspkg)
var version string
if strings.Contains(pkgname, "uek") {
version = strings.Replace(pkgname, "kernel-uek-", "", -1)
} else {
version = strings.Replace(pkgname, "kernel-", "", -1)
}
2023-05-09 17:53:39 +00:00
if sk.DistroRelease <= "7" {
cmd += fmt.Sprintf(" && dracut -v --add-drivers 'e1000 ext4' -f "+
"/boot/initramfs-%s.img %s", version, version)
} else {
cmd += fmt.Sprintf(" && dracut -v --add-drivers 'ata_piix libata' --force-drivers 'e1000 ext4 sd_mod' -f "+
"/boot/initramfs-%s.img %s", version, version)
}
default:
err = fmt.Errorf("%s not yet supported", sk.DistroType.String())
2023-02-15 10:52:36 +00:00
return
}
c.Args = append(c.Args, "-v", volumes.LibModules+":/target/lib/modules")
c.Args = append(c.Args, "-v", volumes.UsrSrc+":/target/usr/src")
c.Args = append(c.Args, "-v", volumes.Boot+":/target/boot")
cmd += " && cp -r /boot /target/"
cmd += " && cp -r /lib/modules /target/lib/"
cmd += " && cp -r /usr/src /target/usr/"
_, err = c.Run("", cmd)
2023-04-05 16:14:30 +00:00
if err != nil {
return
}
2023-03-22 18:08:48 +00:00
slog.Debug().Msgf("Success")
return
}
func findKernelFile(files []os.FileInfo, kname string) (name string, err error) {
2018-11-28 23:53:47 +00:00
for _, file := range files {
2019-08-20 18:57:45 +00:00
if strings.HasPrefix(file.Name(), "vmlinuz") {
2018-11-28 23:53:47 +00:00
if strings.Contains(file.Name(), kname) {
name = file.Name()
return
2018-11-28 23:53:47 +00:00
}
}
}
err = errors.New("cannot find kernel")
return
2018-11-28 23:53:47 +00:00
}
func findInitrdFile(files []os.FileInfo, kname string) (name string, err error) {
2018-11-28 23:53:47 +00:00
for _, file := range files {
2019-08-20 18:57:45 +00:00
if strings.HasPrefix(file.Name(), "initrd") ||
strings.HasPrefix(file.Name(), "initramfs") {
2018-11-28 23:53:47 +00:00
if strings.Contains(file.Name(), kname) {
name = file.Name()
return
2018-11-28 23:53:47 +00:00
}
}
}
err = errors.New("cannot find kernel")
return
2018-11-28 23:53:47 +00:00
}
2023-04-06 19:05:21 +00:00
func genRootfsImage(d containerImageInfo, download bool) (rootfs string, err error) {
2018-11-29 00:01:14 +00:00
usr, err := user.Current()
if err != nil {
return
2018-11-29 00:01:14 +00:00
}
2023-04-06 19:05:21 +00:00
imageFile := d.Name + ".img"
imagesPath := usr.HomeDir + "/.out-of-tree/images/"
os.MkdirAll(imagesPath, os.ModePerm)
rootfs = imagesPath + imageFile
if !fs.PathExists(rootfs) {
if download {
2023-04-06 21:09:12 +00:00
log.Info().Msgf("%v not available, start download", imageFile)
err = downloadImage(imagesPath, imageFile)
}
}
return
2018-11-28 23:53:47 +00:00
}
func updateKernelsCfg(host, download bool) (err error) {
newkcfg := config.KernelConfig{}
if host {
// Get host kernels
newkcfg, err = genHostKernels(download)
if err != nil {
return
}
}
// Get docker kernels
2023-04-06 19:05:21 +00:00
dockerImages, err := listContainerImages()
if err != nil {
return
}
for _, d := range dockerImages {
2023-03-29 17:25:32 +00:00
err = listContainersKernels(d, &newkcfg, download)
if err != nil {
2023-04-06 19:05:21 +00:00
log.Print("gen kernels", d.Name, ":", err)
continue
}
}
stripkcfg := config.KernelConfig{}
for _, nk := range newkcfg.Kernels {
if !hasKernel(nk, stripkcfg) {
stripkcfg.Kernels = append(stripkcfg.Kernels, nk)
}
}
buf, err := toml.Marshal(&stripkcfg)
if err != nil {
return
}
buf = append([]byte("# Autogenerated\n# DO NOT EDIT\n\n"), buf...)
usr, err := user.Current()
if err != nil {
return
}
// TODO move all cfg path values to one provider
kernelsCfgPath := usr.HomeDir + "/.out-of-tree/kernels.toml"
err = ioutil.WriteFile(kernelsCfgPath, buf, 0644)
if err != nil {
return
}
log.Info().Msgf("%s is successfully updated", kernelsCfgPath)
return
}
2023-04-06 19:05:21 +00:00
func listContainersKernels(dii containerImageInfo, newkcfg *config.KernelConfig,
download bool) (err error) {
2018-11-28 23:53:47 +00:00
rootfs, err := genRootfsImage(dii, download)
2018-11-28 23:53:47 +00:00
if err != nil {
return
}
2023-04-06 19:05:21 +00:00
c, err := NewContainer(dii.Name, time.Hour)
2018-11-28 23:53:47 +00:00
if err != nil {
return
}
moddirs, err := ioutil.ReadDir(c.Volumes.LibModules)
2018-11-28 23:53:47 +00:00
if err != nil {
return
}
bootfiles, err := ioutil.ReadDir(c.Volumes.Boot)
if err != nil {
return
}
for _, krel := range moddirs {
log.Debug().Msgf("generate config entry for %s", krel.Name())
var kernelFile, initrdFile string
kernelFile, err = findKernelFile(bootfiles, krel.Name())
if err != nil {
log.Warn().Msgf("cannot find kernel %s", krel.Name())
continue
}
initrdFile, err = findInitrdFile(bootfiles, krel.Name())
if err != nil {
log.Warn().Msgf("cannot find initrd %s", krel.Name())
continue
}
2018-11-28 23:53:47 +00:00
ki := config.KernelInfo{
DistroType: dii.DistroType,
DistroRelease: dii.DistroRelease,
KernelRelease: krel.Name(),
2023-04-06 19:05:21 +00:00
ContainerName: dii.Name,
2018-11-28 23:53:47 +00:00
KernelPath: c.Volumes.Boot + "/" + kernelFile,
InitrdPath: c.Volumes.Boot + "/" + initrdFile,
ModulesPath: c.Volumes.LibModules + "/" + krel.Name(),
2023-02-15 10:52:36 +00:00
RootFS: rootfs,
2018-11-28 23:53:47 +00:00
}
newkcfg.Kernels = append(newkcfg.Kernels, ki)
}
2023-03-22 21:16:00 +00:00
for _, cmd := range []string{
"find /boot -type f -exec chmod a+r {} \\;",
} {
2023-04-07 16:43:56 +00:00
_, err = c.Run(tempDirBase, cmd)
if err != nil {
return
2023-03-22 21:16:00 +00:00
}
2018-11-28 23:53:47 +00:00
}
return
}
func hasKernel(ki config.KernelInfo, kcfg config.KernelConfig) bool {
for _, sk := range kcfg.Kernels {
if sk == ki {
return true
}
}
return false
}
func shuffleStrings(a []string) []string {
// FisherYates shuffle
for i := len(a) - 1; i > 0; i-- {
j := rand.Intn(i + 1)
a[i], a[j] = a[j], a[i]
}
return a
}
2023-04-07 20:52:45 +00:00
func setSigintHandler(variable *bool) {
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt)
go func() {
counter := 0
for _ = range c {
if counter == 0 {
*variable = true
log.Warn().Msg("shutdown requested, finishing work")
log.Info().Msg("^C a couple of times more for an unsafe exit")
} else if counter >= 3 {
log.Fatal().Msg("unsafe exit")
}
counter += 1
}
}()
}
// FIXME too many parameters
func generateKernels(km config.KernelMask, registry string,
commands []config.DockerCommand, max, retries int64,
download, force, headers, shuffle, update bool,
shutdown *bool) (err error) {
log.Info().Msgf("Generating for kernel mask %v", km)
2023-04-06 19:05:21 +00:00
_, err = genRootfsImage(containerImageInfo{Name: km.DockerName()},
download)
2023-04-07 20:52:45 +00:00
if err != nil || *shutdown {
return
}
err = generateBaseDockerImage(registry, commands, km, update)
2023-04-07 20:52:45 +00:00
if err != nil || *shutdown {
return
}
2023-05-10 07:52:44 +00:00
pkgs, err := matchPackages(km)
2023-04-07 20:52:45 +00:00
if err != nil || *shutdown {
return
}
if shuffle {
pkgs = shuffleStrings(pkgs)
}
for i, pkg := range pkgs {
if max <= 0 {
2023-03-18 21:30:07 +00:00
log.Print("Max is reached")
break
}
if *shutdown {
err = nil
return
}
2023-03-22 18:05:13 +00:00
log.Info().Msgf("%d/%d %s", i+1, len(pkgs), pkg)
var attempt int64
for {
attempt++
2023-04-07 20:52:45 +00:00
if *shutdown {
err = nil
return
}
err = installKernel(km, pkg, force, headers)
if err == nil {
max--
2023-04-05 16:36:09 +00:00
break
} else if attempt >= retries {
log.Error().Err(err).Msg("install kernel")
log.Debug().Msg("skip")
break
} else {
log.Warn().Err(err).Msg("install kernel")
2023-04-05 16:40:20 +00:00
time.Sleep(time.Second)
2023-04-06 14:32:05 +00:00
log.Info().Msg("retry")
}
}
}
return
}