src/pkg/dkms/install.go - cos/tools - Git at Google

 package dkms

 import (
 	"context"
 	"fmt"
 	"os"
 	"os/exec"
 	"path"
 	"path/filepath"
 	"strings"

 	"cos.googlesource.com/cos/tools.git/src/pkg/fs"
 	"cos.googlesource.com/cos/tools.git/src/pkg/gcs"
 	"cos.googlesource.com/cos/tools.git/src/pkg/utils"
 	"github.com/golang/glog"
 )

 // Install installs all of the modules from a DKMS package into the install
 // tree.
 //
 // This will add and build the package if it is not already added and built.
 //
 // For each module in the package, this will check if the version being
 // installed is newer than the version of the module which is already
 // installed, if applicable. If the module version is older than the one
 // already installed, this will skip installing that module and emit an info
 // message. options.ForceVersionOverride can be set to bypass the version
 // check and install the module anyway.
 //
 // If options.ModprobeOnInstall is passed, then modprobe will be called on
 // the module after it is copied to the install tree to insert it into the
 // running kernel.
 func Install(pkg *Package, options *Options) error {
 	if !options.Force && IsInstalled(pkg) {
 		glog.Info("package already installed; skipping installation")
 		return nil
 	}

 	if err := Build(pkg, options); err != nil {
 		return err
 	}

 	glog.Infof("installing package %s-%s", pkg.Name, pkg.Version)
 	config, err := LoadConfig(pkg)
 	if err != nil {
 		return err
 	}

 	if config.PreInstall != "" {
 		if utils.RunCommandString(pkg.BuildDir(), config.PreInstall); err != nil {
 			return fmt.Errorf("failed to run pre-install script: %v", err)
 		}
 	}

 	var modulesToInstall []Module
 	if options.ForceVersionOverride {
 		modulesToInstall = config.Modules
 	} else {
 		modules, err := ModulesToInstall(config.Modules, pkg.Trees.Install)
 		if err != nil {
 			return err
 		}
 		modulesToInstall = modules
 	}

 	for _, module := range modulesToInstall {
 		srcPath := module.BuiltPath()
 		dstPath := module.DestPath()

 		glog.Infof("copying %s to %s", srcPath, dstPath)
 		if err := os.MkdirAll(filepath.Dir(dstPath), 0777); err != nil {
 			return err
 		}

 		if err := fs.CopyFile(srcPath, dstPath, 0666); err != nil {
 			return err
 		}
 	}

 	if options.ModprobeOnInstall {
 		if !options.NoDepmod {
 			if err := Depmod(); err != nil {
 				return err
 			}
 		}

 		if err := ModprobeModules(config.Modules); err != nil {
 			return err
 		}
 	}

 	if config.PostInstall != "" {
 		if utils.RunCommandString(pkg.BuildDir(), config.PostInstall); err != nil {
 			return fmt.Errorf("failed to run post-install script: %v", err)
 		}
 	}

 	return nil
 }

 // CachedInstall installs all of the modules from a DKMS package into the
 // install tree, using CachedBuild to build the package if necessary.
 //
 // See Install for more information on how modules are installed locally.
 func CachedInstall(ctx context.Context, pkg *Package, cache *gcs.GCSBucket, options *Options) error {
 	if err := CachedBuild(ctx, pkg, cache, options); err != nil {
 		return err
 	}

 	return Install(pkg, options)
 }

 // ModulesToInstall returns the list of modules which should be installed.
 //
 // This takes a list of candidate modules to install and a directory where
 // they would be installed and checks for each module if there is a newer
 // version of that module already installed. If there is a newer or equal
 // version already installed, the module is omitted from the output list
 // and an info message is emitted.
 func ModulesToInstall(modules []Module, installTree string) ([]Module, error) {
 	installedKernelModules, err := FindKernelModules(installTree)
 	if err != nil {
 		return nil, fmt.Errorf("could not find all installed kernel modules")
 	}

 	var result []Module
 	for _, module := range modules {
 		installName := module.DestName + ".ko"
 		installedModulePath, ok := installedKernelModules[installName]
 		if !ok {
 			result = append(result, module)
 			continue // module is not yet installed
 		}

 		installedVersion, err := ModuleVersion(installedModulePath)
 		if err != nil {
 			return nil, fmt.Errorf("could not determine installed module version for module %s: %s", module.DestName, err)
 		}

 		builtVersion, err := ModuleVersion(module.BuiltPath())
 		if err != nil {
 			return nil, fmt.Errorf("could not determine built module version for module %s: %v", module.BuiltName, err)
 		}

 		comparison := CompareVersions(builtVersion, installedVersion)
 		if comparison < 0 {
 			glog.Infof(
 				"installed version of module %s is newer than built version (%s > %s); not reinstalling; pass --force-version-override to install anyway",
 				module.DestName, installedVersion, builtVersion,
 			)
 		} else if comparison == 0 {
 			glog.Infof(
 				"module %s is already installed with version %s; not reinstalling; pass --force-version-override to install anyway",
 				module.DestName, installedVersion,
 			)
 		} else {
 			result = append(result, module)
 		}
 	}

 	return result, nil
 }

 // FindKernelModules returns a map from kernel module names to the paths to
 // those modules for each module in a directory tree.
 func FindKernelModules(root string) (map[string]string, error) {
 	modules := make(map[string]string)
 	if err := findKernelModules(root, modules); err != nil {
 		return nil, err
 	}
 	return modules, nil
 }

 func findKernelModules(root string, modules map[string]string) error {
 	entries, err := os.ReadDir(root)
 	if err != nil {
 		if os.IsNotExist(err) {
 			glog.Infof("skipping kernel module search for directory %s because it does not exist: %v", root, err)
 			return nil
 		}

 		return fmt.Errorf("could not read directory %s: %v", root, err)
 	}

 	for _, entry := range entries {
 		name := entry.Name()
 		if entry.IsDir() {
 			if err := findKernelModules(path.Join(root, name), modules); err != nil {
 				return err
 			}
 		} else if strings.HasSuffix(name, ".ko") {
 			modules[name] = path.Join(root, name)
 		}
 	}

 	return nil
 }

 // isInstalled returns whether or not all of a package's modules have been
 // installed.
 // If the package has an invalid dkms.conf, this returns false.
 func isInstalled(pkg *Package) bool {
 	config, err := LoadConfig(pkg)
 	if err != nil {
 		return false
 	}
 	for _, module := range config.Modules {
 		if !fs.IsFile(module.DestPath()) {
 			return false
 		}
 	}

 	return true
 }

 // IsInstalled returns whether or not a package has been built in the DKMS
 // build tree and all of its modules have been installed in the install tree.
 func IsInstalled(pkg *Package) bool {
 	return isInstalled(pkg) && IsBuilt(pkg)
 }

 // ModprobeModules modprobes a list of modules, ignoring ones which have
 // already been inserted into the running kernel.
 func ModprobeModules(modules []Module) error {
 	insertedModules, err := InsertedModules()
 	if err != nil {
 		return fmt.Errorf("could not get list of inserted modules: %v; skipping modprobe", err)
 	}

 	for _, module := range modules {
 		_, inserted := insertedModules[module.DestName]
 		if inserted {
 			glog.Infof("module %s is already inserted; skipping", module.DestName)
 			continue
 		}

 		if err := ModprobeModule(module.DestName); err != nil {
 			return err
 		}
 	}

 	return nil
 }

 // Depmod runs depmod to recalculate module dependencies.
 // This is required for modprobe to work properly the first time a module has
 // been installed, or if its dependencies change.
 func Depmod() error {
 	cmd := exec.Command("depmod")
 	out, err := cmd.CombinedOutput()
 	if err == nil {
 		glog.Info(string(out))
 	} else {
 		glog.Error(string(out))
 		return fmt.Errorf("error running depmod to set up module dependencies: %v", err)
 	}
 	return nil
 }

 // ModprobeModule runs modprobe on a module to insert it into the running
 // kernel.
 func ModprobeModule(name string) error {
 	cmd := exec.Command("modprobe", name)
 	out, err := cmd.CombinedOutput()
 	if err == nil {
 		glog.Info(string(out))
 	} else {
 		glog.Error(string(out))
 		return fmt.Errorf("error running modprobe with module %s: %v", name, err)
 	}
 	return nil
 }

 // InsertedModules returns the list of modules which have been inserted into
 // the running kernel.
 func InsertedModules() (map[string]bool, error) {
 	cmd := exec.Command("lsmod")
 	out, err := cmd.CombinedOutput()
 	if err != nil {
 		glog.Error(string(out))
 		return nil, fmt.Errorf("error listing modules with lsmod: %v", err)
 	}
 	outStr := string(out)

 	moduleNames := make(map[string]bool)
 	lines := strings.Split(outStr, "\n")[1:]
 	for _, line := range lines {
 		fields := strings.Fields(line)
 		if len(fields) > 0 {
 			name := fields[0]
 			moduleNames[name] = true
 		}
 	}

 	return moduleNames, nil
 }
	package dkms

	import (
	"context"
	"fmt"
	"os"
	"os/exec"
	"path"
	"path/filepath"
	"strings"

	"cos.googlesource.com/cos/tools.git/src/pkg/fs"
	"cos.googlesource.com/cos/tools.git/src/pkg/gcs"
	"cos.googlesource.com/cos/tools.git/src/pkg/utils"
	"github.com/golang/glog"
	)

	// Install installs all of the modules from a DKMS package into the install
	// tree.
	//
	// This will add and build the package if it is not already added and built.
	//
	// For each module in the package, this will check if the version being
	// installed is newer than the version of the module which is already
	// installed, if applicable. If the module version is older than the one
	// already installed, this will skip installing that module and emit an info
	// message. options.ForceVersionOverride can be set to bypass the version
	// check and install the module anyway.
	//
	// If options.ModprobeOnInstall is passed, then modprobe will be called on
	// the module after it is copied to the install tree to insert it into the
	// running kernel.
	func Install(pkg Package, options Options) error {
	if !options.Force && IsInstalled(pkg) {
	glog.Info("package already installed; skipping installation")
	return nil
	}

	if err := Build(pkg, options); err != nil {
	return err
	}

	glog.Infof("installing package %s-%s", pkg.Name, pkg.Version)
	config, err := LoadConfig(pkg)
	if err != nil {
	return err
	}

	if config.PreInstall != "" {
	if utils.RunCommandString(pkg.BuildDir(), config.PreInstall); err != nil {
	return fmt.Errorf("failed to run pre-install script: %v", err)
	}
	}

	var modulesToInstall []Module
	if options.ForceVersionOverride {
	modulesToInstall = config.Modules
	} else {
	modules, err := ModulesToInstall(config.Modules, pkg.Trees.Install)
	if err != nil {
	return err
	}
	modulesToInstall = modules
	}

	for _, module := range modulesToInstall {
	srcPath := module.BuiltPath()
	dstPath := module.DestPath()

	glog.Infof("copying %s to %s", srcPath, dstPath)
	if err := os.MkdirAll(filepath.Dir(dstPath), 0777); err != nil {
	return err
	}

	if err := fs.CopyFile(srcPath, dstPath, 0666); err != nil {
	return err
	}
	}

	if options.ModprobeOnInstall {
	if !options.NoDepmod {
	if err := Depmod(); err != nil {
	return err
	}
	}

	if err := ModprobeModules(config.Modules); err != nil {
	return err
	}
	}

	if config.PostInstall != "" {
	if utils.RunCommandString(pkg.BuildDir(), config.PostInstall); err != nil {
	return fmt.Errorf("failed to run post-install script: %v", err)
	}
	}

	return nil
	}

	// CachedInstall installs all of the modules from a DKMS package into the
	// install tree, using CachedBuild to build the package if necessary.
	//
	// See Install for more information on how modules are installed locally.
	func CachedInstall(ctx context.Context, pkg Package, cache gcs.GCSBucket, options *Options) error {
	if err := CachedBuild(ctx, pkg, cache, options); err != nil {
	return err
	}

	return Install(pkg, options)
	}

	// ModulesToInstall returns the list of modules which should be installed.
	//
	// This takes a list of candidate modules to install and a directory where
	// they would be installed and checks for each module if there is a newer
	// version of that module already installed. If there is a newer or equal
	// version already installed, the module is omitted from the output list
	// and an info message is emitted.
	func ModulesToInstall(modules []Module, installTree string) ([]Module, error) {
	installedKernelModules, err := FindKernelModules(installTree)
	if err != nil {
	return nil, fmt.Errorf("could not find all installed kernel modules")
	}

	var result []Module
	for _, module := range modules {
	installName := module.DestName + ".ko"
	installedModulePath, ok := installedKernelModules[installName]
	if !ok {
	result = append(result, module)
	continue // module is not yet installed
	}

	installedVersion, err := ModuleVersion(installedModulePath)
	if err != nil {
	return nil, fmt.Errorf("could not determine installed module version for module %s: %s", module.DestName, err)
	}

	builtVersion, err := ModuleVersion(module.BuiltPath())
	if err != nil {
	return nil, fmt.Errorf("could not determine built module version for module %s: %v", module.BuiltName, err)
	}

	comparison := CompareVersions(builtVersion, installedVersion)
	if comparison < 0 {
	glog.Infof(
	"installed version of module %s is newer than built version (%s > %s); not reinstalling; pass --force-version-override to install anyway",
	module.DestName, installedVersion, builtVersion,
	)
	} else if comparison == 0 {
	glog.Infof(
	"module %s is already installed with version %s; not reinstalling; pass --force-version-override to install anyway",
	module.DestName, installedVersion,
	)
	} else {
	result = append(result, module)
	}
	}

	return result, nil
	}

	// FindKernelModules returns a map from kernel module names to the paths to
	// those modules for each module in a directory tree.
	func FindKernelModules(root string) (map[string]string, error) {
	modules := make(map[string]string)
	if err := findKernelModules(root, modules); err != nil {
	return nil, err
	}
	return modules, nil
	}

	func findKernelModules(root string, modules map[string]string) error {
	entries, err := os.ReadDir(root)
	if err != nil {
	if os.IsNotExist(err) {
	glog.Infof("skipping kernel module search for directory %s because it does not exist: %v", root, err)
	return nil
	}

	return fmt.Errorf("could not read directory %s: %v", root, err)
	}

	for _, entry := range entries {
	name := entry.Name()
	if entry.IsDir() {
	if err := findKernelModules(path.Join(root, name), modules); err != nil {
	return err
	}
	} else if strings.HasSuffix(name, ".ko") {
	modules[name] = path.Join(root, name)
	}
	}

	return nil
	}

	// isInstalled returns whether or not all of a package's modules have been
	// installed.
	// If the package has an invalid dkms.conf, this returns false.
	func isInstalled(pkg *Package) bool {
	config, err := LoadConfig(pkg)
	if err != nil {
	return false
	}
	for _, module := range config.Modules {
	if !fs.IsFile(module.DestPath()) {
	return false
	}
	}

	return true
	}

	// IsInstalled returns whether or not a package has been built in the DKMS
	// build tree and all of its modules have been installed in the install tree.
	func IsInstalled(pkg *Package) bool {
	return isInstalled(pkg) && IsBuilt(pkg)
	}

	// ModprobeModules modprobes a list of modules, ignoring ones which have
	// already been inserted into the running kernel.
	func ModprobeModules(modules []Module) error {
	insertedModules, err := InsertedModules()
	if err != nil {
	return fmt.Errorf("could not get list of inserted modules: %v; skipping modprobe", err)
	}

	for _, module := range modules {
	_, inserted := insertedModules[module.DestName]
	if inserted {
	glog.Infof("module %s is already inserted; skipping", module.DestName)
	continue
	}

	if err := ModprobeModule(module.DestName); err != nil {
	return err
	}
	}

	return nil
	}

	// Depmod runs depmod to recalculate module dependencies.
	// This is required for modprobe to work properly the first time a module has
	// been installed, or if its dependencies change.
	func Depmod() error {
	cmd := exec.Command("depmod")
	out, err := cmd.CombinedOutput()
	if err == nil {
	glog.Info(string(out))
	} else {
	glog.Error(string(out))
	return fmt.Errorf("error running depmod to set up module dependencies: %v", err)
	}
	return nil
	}

	// ModprobeModule runs modprobe on a module to insert it into the running
	// kernel.
	func ModprobeModule(name string) error {
	cmd := exec.Command("modprobe", name)
	out, err := cmd.CombinedOutput()
	if err == nil {
	glog.Info(string(out))
	} else {
	glog.Error(string(out))
	return fmt.Errorf("error running modprobe with module %s: %v", name, err)
	}
	return nil
	}

	// InsertedModules returns the list of modules which have been inserted into
	// the running kernel.
	func InsertedModules() (map[string]bool, error) {
	cmd := exec.Command("lsmod")
	out, err := cmd.CombinedOutput()
	if err != nil {
	glog.Error(string(out))
	return nil, fmt.Errorf("error listing modules with lsmod: %v", err)
	}
	outStr := string(out)

	moduleNames := make(map[string]bool)
	lines := strings.Split(outStr, "\n")[1:]
	for _, line := range lines {
	fields := strings.Fields(line)
	if len(fields) > 0 {
	name := fields[0]
	moduleNames[name] = true
	}
	}

	return moduleNames, nil
	}