path: root/initramfs/OpenSLX/MakeInitRamFS/Engine.pm

# Copyright (c) 2006, 2007 - OpenSLX GmbH
#
# This program is free software distributed under the GPL version 2.
# See http://openslx.org/COPYING
#
# If you have any feedback please consult http://openslx.org/feedback and
# send your suggestions, praise, or complaints to feedback@openslx.org
#
# General information about OpenSLX can be found at http://openslx.org/
# -----------------------------------------------------------------------------
# MakeInitialRamFS::Engine.pm
#	- provides driver engine for MakeInitialRamFS API.
# -----------------------------------------------------------------------------
package OpenSLX::MakeInitRamFS::Engine;

use strict;
use warnings;

use File::Basename;
use File::Find;
use File::Path;
use POSIX qw(strftime);

use OpenSLX::Basics;
use OpenSLX::LibScanner;
use OpenSLX::OSPlugin::Roster;
use OpenSLX::Utils;

# TODO: implement support for the following (either here or as plugin):
#			wlan
#			tpm
#			cdboot (must be implemented here!)

################################################################################
### interface methods
################################################################################
sub new
{
	my $class  = shift;
	my $params = shift || {};

	checkParams($params, { 
		'attrs'          => '!',
		'debug-level'    => '?',
		'export-name'    => '!',
		'export-uri'     => '!',
		'initramfs'      => '!',
		'kernel-params'  => '!',
		'kernel-version' => '!',
		'plugins'        => '!',
		'root-path'      => '!',
		'slx-version'    => '!',
		'system-name'    => '!',
	} );

	my $self = $params;

	$self->{'system-name'} =~ m{^([^\-]+)-([^:\-]+)}
		or die "unable to extract distro-info from $self->{'system-name'}!";

	$self->{'distro-name'} = $1;
	$self->{'distro-ver'} = $2;

	my %distroMap = (
		'debian' => 'Debian',
		'suse'   => 'SUSE',
		'ubuntu' => 'Ubuntu',
	);
	my $distroModule = $distroMap{$self->{'distro-name'}} || 'Base';
	$self->{distro} = instantiateClass(
		"OpenSLX::MakeInitRamFS::Distro::$distroModule"
	);
	
	$self->{'lib-scanner'} 
		= OpenSLX::LibScanner->new({ 'root-path' => $self->{'root-path'} });
	
	$self->{'required-libs'}            = {};
	$self->{'suggested-kernel-modules'} = [];
	$self->{'filtered-kernel-modules'}  = [];

	return bless $self, $class;
}

sub execute
{
	my $self   = shift;
	my $dryRun = shift;

	$self->_collectCMDs();

	$self->_executeCMDs() unless $dryRun;

	return;
}

sub haveKernelParam
{
	my $self  = shift;
	my $param = shift;
	
	return ref $param eq 'Regexp'
		? grep { $_ =~ $param } @{ $self->{'kernel-params'} }
		: grep { $_ eq $param } @{ $self->{'kernel-params'} };
}

sub addKernelParams
{
	my $self = shift;
	
	push @{ $self->{'kernel-params'} }, @_;
	
	return;
}

sub kernelParams
{
	my $self = shift;
	
	return @{ $self->{'kernel-params'} };
}

sub addKernelModules
{
	my $self = shift;
	
	push @{ $self->{'suggested-kernel-modules'} }, @_;
	
	return;
}

################################################################################
### implementation methods
################################################################################
sub _collectCMDs
{
	my $self = shift;
	
	$self->{CMDs} = [];

	$self->_setupBuildPath();

	$self->_addRequiredFSModsAndTools();
	
	$self->_writeInitramfsSetup();
	$self->_writeSlxSystemConf();

	$self->_copyDistroSpecificFiles();
	$self->_copyInitramfsFiles();
	
	$self->_copyBusybox();
	
	$self->_copyDhcpClient();

	$self->_copyRamfsTools();
	
	$self->_copyRequiredFSTools();

	$self->_copyRequiredLayeredFSTools();

	$self->_copyPreAndPostinitFiles();

	if ($self->{'debug-level'}) {
		$self->_copyDebugTools();
	}

	$self->_calloutToPlugins();

	$self->{distro}->applyChanges($self);

	$self->_copyKernelModules();
	
	$self->_copyRequiredLibs();
	
	$self->_createInitRamFS();

	return;
}

sub _executeCMDs
{
	my $self = shift;
	
	foreach my $cmd (@{$self->{CMDs}}) {
		if (ref($cmd) eq 'HASH') {
			vlog(3, "writing $cmd->{file}");
			my $flags = defined $cmd->{mode} ? { mode => $cmd->{mode} } : undef;
			spitFile($cmd->{file}, $cmd->{content}, $flags);
		}
		else {
			vlog(3, "executing: $cmd");
			if (slxsystem($cmd)) {
				die _tr(
					"unable to execute shell-cmd\n\t%s", $cmd
				);
			}
		}
	}

	return;
}

sub addCMD
{
	my $self = shift;
	my $cmd  = shift;
	
	push @{$self->{CMDs}}, $cmd;

	return;
}
	
sub _setupBuildPath
{
	my $self = shift;
	
	my $buildPath = "$openslxConfig{'temp-path'}/slx-initramfs";
	$self->addCMD("rm -rf $buildPath");

	my @stdFolders = qw(
		bin 
		dev 
		etc
		etc/init-hooks
		etc/sysconfig
		lib
		mnt 
		proc 
		root 
		sys 
		tmp 
		usr/share
		var/lib
		var/lib/nfs/state
		var/run
	);
	$self->addCMD(
		'mkdir -p ' . join(' ', map { "$buildPath/$_"; } @stdFolders)
	);
	$self->addCMD("ln -sfn /bin $buildPath/sbin");
	
	$self->{'build-path'} = $buildPath;
	
	return;
}
	
sub _copyDistroSpecificFiles
{
	my $self = shift;

	my $distroSpecsPath = "$openslxConfig{'base-path'}/share/distro-specs";

	my $distroName = $self->{'distro-name'};
	my $distroVer = $self->{'distro-ver'};
	
	# concatenate default- and distro-specific configuration into one file
	my $config = slurpFile("$distroSpecsPath/$distroName/config-default");
	$config .= "\n";
	$config .= slurpFile("$distroSpecsPath/$distroName/config-$distroVer");
	$self->addCMD( {
		file    => "$self->{'build-path'}/etc/sysconfig/config",
		content => $config,
	} );
		
	# concatenate default- and distro-specific functions into one file
	my $functions = slurpFile("$distroSpecsPath/$distroName/functions-default");
	$functions .= "\n";
	$functions 
		.= slurpFile("$distroSpecsPath/$distroName/functions-$distroVer");
	$self->addCMD( {
		file    => "$self->{'build-path'}/etc/distro-functions",
		content => $functions,
	} );
	
	my $defaultsPath = "$distroSpecsPath/$distroName/files-default";
	if (-e $defaultsPath) {
		$self->addCMD(
			"cp -a $defaultsPath $self->{'build-path'}/etc/sysconfig/files"
		);
	}
		
	return 1;
}

sub _copyInitramfsFiles
{
	my $self = shift;

	my $initramfsPath = "$openslxConfig{'base-path'}/share/initramfs";

	find(
		{
			wanted => sub {
				my $len = length($initramfsPath);
				my $file = $File::Find::name;
				my $relName = length($file) > $len ? substr($file, $len+1) : '';
				if (-d) {
					$self->addCMD("mkdir -p $self->{'build-path'}/$relName");
				} elsif (-l $file) {
					my $target = readlink $file;
					$self->addCMD(
						"ln -sf $target $self->{'build-path'}/$relName"
					);
				} elsif (qx{file $file} =~ m{ELF}) {
					$self->addCMD(
						"cp -p $file $self->{'build-path'}/$relName"
					);
				} else {
					my $text = slurpFile($file, { 'io-layer' => 'bytes' } );

					# replace macros
					# TODO: find out what these mean and maybe find a
					#       different, better solution
					my %macro = (
						'COMDIRINDXS' => '/tmp/scratch /var/lib/nobody',
						'COMETCEXCL'  => "XF86Config*\nissue*\nmtab*\nfstab*\n",
						'KERNVER'     => $self->{'kernel-version'},
						# keep serverip as it is (it is handled by init itself)
						'serverip'    => '@@@serverip@@@',
					);
					$text =~ s{\@\@\@([^\@]+)\@\@\@}{
						if (!exists $macro{$1}) {
							warn _tr(
								'unknown macro @@@%s@@@ found in %s', 
								$1, $File::Find::name
							);
							'';
						} else {
							$macro{$1};
						}
					}eogms;
					
					# force shebang with ash
					$text =~ s{\A#!\s*/bin/.+?$}{#!/bin/ash}ms;
					
					$self->addCMD( {
						file    => "$self->{'build-path'}/$relName",
						content => $text,
						mode    => (-x $file ? 0755 : undef),
					} );
				}
			},
			no_chdir => 1,
		},
		$initramfsPath
	);

	return;
}

sub _copyBusybox
{
	my $self = shift;

	$self->_copyPlatformSpecificBinary(
		"$openslxConfig{'base-path'}/share/busybox/busybox", '/bin/busybox'
	);
	
	my $busyboxForHost 
		= "$openslxConfig{'base-path'}/share/busybox/busybox"
			. ( hostIs64Bit() ? '.x86_64' : '.i586' );

	my $busyboxHelp = qx{$busyboxForHost --help};
	if ($busyboxHelp !~ m{defined functions:(.+)\z}ims) {
		die "unable to parse busybox --help output:\n$busyboxHelp";
	}
	my $rawAppletList = $1;
	my @busyboxApplets 
		=	map {
				$_ =~ s{\s+}{}igms;
				$_;
			}
			split m{,}, $rawAppletList;
	foreach my $applet (@busyboxApplets) {
		$self->addCMD("ln -sf /bin/busybox $self->{'build-path'}/bin/$applet");
	}
	
	# fake the sh link in busybox environment
	my $shFake = "#!/bin/ash\n/bin/ash \$\@";
	$self->addCMD( {
		file    => "$self->{'build-path'}/bin/sh", 
		content => $shFake,
		mode    => 0755
	} );

	return;
}

sub _copyRamfsTools
{
	my $self = shift;
	
	my @ramfsTools = qw(ddcprobe 915resolution);
	foreach my $tool (@ramfsTools) {
		$self->_copyPlatformSpecificBinary(
			"$openslxConfig{'base-path'}/share/ramfstools/$tool", 
			"/bin/$tool"
		);
	}
	
	return;
}
	
sub _copyDebugTools
{
	my $self = shift;
	
	my @debugTools = qw(strace);
	foreach my $tool (@debugTools) {
		my $toolPath = $self->_findBinary($tool);
		if (!$toolPath) {
			warn _tr('debug-tool "%s" is not available', $tool);
			next;
		}
		$self->addCMD("cp -p $toolPath $self->{'build-path'}/bin");
		$self->_addRequiredLibsFor($toolPath);
	}
	
	return;
}
	
sub _copyDhcpClient
{
	my $self = shift;
	
	# TODO: instead of using dhclient, we should check if the client
	#       provided by busybox still does not support fetching NIS stuff
	#       (and implement that if it doesn't)

	my $toolPath = $self->_findBinary('dhclient');
	if (!$toolPath) {
		warn _tr('tool "dhclient" is not available, using "udhcpc" instead');
		return;
	}
	$self->addCMD("cp -p $toolPath $self->{'build-path'}/bin");
	$self->_addRequiredLibsFor($toolPath);
	
	return;
}
	
sub _findBinary
{
	my $self   = shift;
	my $binary = shift;
	
	my @binDirs = qw(
		bin sbin usr/bin usr/sbin usr/local/bin usr/local/sbin usr/bin/X11
	);
	foreach my $binDir (@binDirs) {
		my $binPath = "$self->{'root-path'}/$binDir/$binary";
		return $binPath if -f $binPath && -x $binPath;
	}
	
	return;
}
	
sub _copyPlatformSpecificBinary
{
	my $self       = shift;
	my $binaryPath = shift;
	my $targetPath = shift;

	my $binary = $self->_platformSpecificFileFor($binaryPath);
	
	$self->addCMD("cp -p $binary $self->{'build-path'}$targetPath");
	$self->_addRequiredLibsFor($binary);

	return;
}

sub _copyRequiredFSTools
{
	my $self = shift;

	foreach my $tool (@{$self->{'fs-tools'}}) {
		my $toolPath = $self->_findBinary($tool);
		if (!$toolPath) {
			die _tr('filesystem-tool "%s" is not available, giving up!', $tool);
		}
		$self->addCMD("cp -p $toolPath $self->{'build-path'}/bin");
		$self->_addRequiredLibsFor($toolPath);
	}

	return;
}

sub _copyRequiredLayeredFSTools
{
	my $self = shift;

	my @tools;
	if ($self->haveKernelParam('unionfs')) {
		push @tools, 'unionctl';
	}
	if ($self->haveKernelParam('cowloop')) {
		push @tools, 'cowdev';
	}
	foreach my $tool (@tools) {
		my $toolPath = $self->_findBinary($tool);
		if (!$toolPath) {
			die _tr(
				'layered-fs-tool "%s" is not available, giving up!', $tool
			);
		}
		$self->addCMD("cp -p $toolPath $self->{'build-path'}/bin");
		$self->_addRequiredLibsFor($toolPath);
	}

	return;
}

sub _copyRequiredLibs
{
	my $self = shift;

	# separate 64-bit libs from 32-bit libs and copy them into different
	# destination folders
	my @libs64 = grep { $_ =~ m{/lib64/} } keys %{$self->{'required-libs'}};
	my @libs32 = grep { $_ !~ m{/lib64/} } keys %{$self->{'required-libs'}};
	if (@libs64) {
		$self->addCMD("mkdir -p $self->{'build-path'}/lib64");
		foreach my $lib (@libs64) {
			$self->addCMD("cp -p $lib $self->{'build-path'}/lib64/");
		}
	}
	foreach my $lib (@libs32) {
		$self->addCMD("cp -p $lib $self->{'build-path'}/lib/");
	}

	return;
}

sub _addRequiredLibsFor
{
	my $self   = shift;
	my $binary = shift;

	my @libs = $self->{'lib-scanner'}->determineRequiredLibs($binary);
	foreach my $lib (@libs) {
		$self->_addRequiredLib($lib);
	}

	return;
}

sub _addRequiredLib
{
	my $self = shift;
	my $lib  = shift;

	$self->{'required-libs'}->{$lib} = 1;

	return;
}

sub _addFilteredKernelModules
{
	my $self   = shift;

	push @{ $self->{'filtered-kernel-modules'} }, @_;

	return;
}

sub _copyKernelModules
{
	my $self = shift;
	
	# read modules.dep and use it to determine module dependencies
	my $sourcePath = "$self->{'root-path'}/lib/modules/$self->{'kernel-version'}";
	my @modulesDep = slurpFile("$sourcePath/modules.dep")
		or die _tr('unable to open %s!', "$sourcePath/modules.dep");
	my (%dependentModules, %modulePath, %modulesToBeCopied);
	foreach my $modulesDep (@modulesDep) { 
		next if $modulesDep !~ m{^(.+?)/([^/]+)\.ko:\s*(.*?)\s*$};
		my $path = $1;
		my $module = $2;
		my $dependentsList = $3;
		my $fullModulePath = "$path/$module.ko";
		$modulePath{$module} = [] if !exists $modulePath{$module};
		push @{$modulePath{$module}}, $fullModulePath;
		$dependentModules{$fullModulePath} = [ split ' ', $dependentsList ];
	}

	my $targetPath 
		= "$self->{'build-path'}/lib/modules/$self->{'kernel-version'}";
	$self->addCMD("mkdir -p $targetPath");
	$self->addCMD("cp -p $sourcePath/modules.* $targetPath/");
	
	# TODO: find out what's the story behing the supposedly required
	#       modules 'af_packet', 'unix' and 'hid' (which seem to be
	#       missing at least on some systems
	my @kernelModules = qw(
		af_packet unix hid usbhid uhci-hcd ohci-hcd
	);
	push @kernelModules, @{ $self->{'suggested-kernel-modules'} };

	push @kernelModules, split ' ', $self->{attrs}->{ramfs_fsmods};
	push @kernelModules, split ' ', $self->{attrs}->{ramfs_miscmods};
	push @kernelModules, split ' ', $self->{attrs}->{ramfs_nicmods};

	# a function that determines dependent modules recursively
	my $addDependentsSub;
	$addDependentsSub = sub {
		my $modulePath = shift;
		foreach my $dependentModule (@{$dependentModules{$modulePath}}) {
			next if $modulesToBeCopied{$dependentModule};
			$modulesToBeCopied{$dependentModule} = 1;
			$addDependentsSub->($dependentModule);
		}
	};

	# start with the given kernel modules (names) and build a list of all
	# required modules
	foreach my $kernelModule (@kernelModules) {
		if (!$modulePath{$kernelModule}) {
			if (! grep { $_ eq $kernelModule	} 
				@{ $self->{'filtered-kernel-modules'} }
			) {
				warn _tr(
					'kernel module "%s" not found (in modules.dep)', 
					$kernelModule
				);
			}
		}
		foreach my $modulePath (@{$modulePath{$kernelModule}}) {
			next if $modulesToBeCopied{$modulePath};
			$modulesToBeCopied{$modulePath} = 1;
			$addDependentsSub->($modulePath);
		}
	}
	
	# copy all the modules that we think are required
	foreach my $moduleToBeCopied (sort keys %modulesToBeCopied) {
		my $targetDir = "$self->{'build-path'}" . dirname($moduleToBeCopied);
		$self->addCMD("mkdir -p $targetDir");
		my $source = followLink(
			"$self->{'root-path'}$moduleToBeCopied", $self->{'root-path'}
		);
		my $target = "$self->{'build-path'}$moduleToBeCopied";
		$self->addCMD("cp -p --dereference $source $target");
	}
	
	return;
}

sub _copyPreAndPostinitFiles
{
	my $self = shift;

	foreach my $cfg (
		'default/initramfs/preinit.local',
		"$self->{'system-name'}/initramfs/preinit.local",
		'default/initramfs/postinit.local',
        "$self->{'system-name'}/initramfs/postinit.local"
	) {
		my $cfgPath = "$openslxConfig{'private-path'}/config/$cfg";
		next if !-f $cfgPath;
		$self->addCMD("cp -p $cfgPath $self->{'build-path'}/bin/");
	}
	return;
}

sub _platformSpecificFileFor
{
	my $self   = shift;
	my $binary = shift;

	if ($self->{'system-name'} =~ m{64}) {
		return $binary . '.x86_64';
	}
	return $binary . '.i586';
}

sub _addRequiredFSModsAndTools
{
	my $self = shift;
	
	my $osExportEngine = instantiateClass("OpenSLX::OSExport::Engine");
	$osExportEngine->initializeFromExisting($self->{'export-name'});
	my $fsMods = $self->{attrs}->{ramfs_fsmods} || '';
	foreach my $fsMod ($osExportEngine->requiredFSMods()) {
		$fsMods .= " $fsMod" if $fsMods !~ m{$fsMod};
	}
	$self->{attrs}->{ramfs_fsmods} = $fsMods;
	
	my @fsTools = $osExportEngine->requiredFSTools();
	$self->{'fs-tools'} = \@fsTools;

	return;
}

sub _writeInitramfsSetup
{
	my $self = shift;
	
	# generate initramfs-setup file containing attributes that are
	# relevant for the initramfs only (before there's a root-FS):
	my $initramfsAttrs = {
		'host_name'		 => 'slx-client', # just to have something at all
		'ramfs_fsmods'   => $self->{attrs}->{ramfs_fsmods} || '',
		'ramfs_miscmods' => $self->{attrs}->{ramfs_miscmods} || '',
		'ramfs_nicmods'  => $self->{attrs}->{ramfs_nicmods} || '',
		'rootfs'         => $self->{'export-uri'} || '',
	};
	my $content = "# attributes set by slxconfig-demuxer:\n";
	foreach my $attr (keys %$initramfsAttrs) {
		$content .= qq[$attr="$initramfsAttrs->{$attr}"\n];
	}
	$self->addCMD( {
		file    => "$self->{'build-path'}/etc/initramfs-setup", 
		content => $content
	} );
	
	return;
}

sub _writeSlxSystemConf
{
	my $self = shift;
	
	# generate slxsystem.conf file with variables that are needed
	# in stage3 init.
	# TODO: either put this stuff into initramfs-setup or find another solution
	my $date = strftime("%d.%m.%Y", localtime);
	my $slxConf = unshiftHereDoc(<<"	End-of-Here");
		slxconf_date=$date
		slxconf_kernver=$self->{'kernel-version'}
		slxconf_listnwmod="$self->{attrs}->{ramfs_nicmods}"
		slxconf_distro_name=$self->{'distro-name'}
		slxconf_distro_ver=$self->{'distro-ver'}
		slxconf_system_name=$self->{'system-name'}
		slxconf_slxver="$self->{'slx-version'}"
	End-of-Here
	$self->addCMD( {
		file    => "$self->{'build-path'}/etc/sysconfig/slxsystem.conf", 
		content => $slxConf
	} );

	return;
}

sub _calloutToPlugins
{
	my $self = shift;

	my $pluginInitdPath = "$self->{'build-path'}/etc/plugin-init.d";
	my $initHooksPath   = "$self->{'build-path'}/etc/init-hooks";
	$self->addCMD("mkdir -p $pluginInitdPath $initHooksPath");

	foreach my $pluginName (@{$self->{'plugins'}}) {
		my $plugin = OpenSLX::OSPlugin::Roster->getPlugin($pluginName);
		next if !$plugin;
		$plugin->setupPluginInInitramfs($self->{attrs}, $self);
	}
	return;
}

sub _createInitRamFS
{
	my $self = shift;

	my $buildPath = $self->{'build-path'};
	$self->addCMD(
		"cd $buildPath "
		. "&& find . "
			. "| cpio -H newc --quiet --create "
			. "| gzip -9 >$self->{initramfs}"
	);

	return;
}

1;
################################################################################

=pod

=head1 NAME

OpenSLX::MakeInitRamFS::Engine

=head1 SYNOPSIS

=head1 DESCRIPTION

...

=cut