Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

executable file 1218 lines (1006 sloc) 41.501 kb
#!/usr/bin/env perl
#
# SlugImage : Manipulate NSLU2 firmware images
# Dwayne Fontenot (jacques)
# Rod Whitby (rwhitby)
# www.nslu2-linux.org
#
# Copyright (c) 2004, 2006, Dwayne Fontenot & Rod Whitby
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
# Neither the name of the NSLU2-Linux Development Team nor the names
# of its contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#
use strict;
use warnings;
use Getopt::Long qw(:config no_ignore_case);
use POSIX qw(tmpnam);
my($debug) = 0;
my($quiet) = 0;
my($flash_start) = 0x50000000;
my($flash_len) = 0x00800000;
my($block_size) = 0x00020000;
my($kernel_offset) = 0x00060000;
my($kernel_size) = 0x00100000;
my($ramdisk_offset) = 0x00160000;
my(@cleanup);
# The last 70 bytes of the SercommRedBootTrailer (i.e. excluding MAC
# address). Needed to create an image with an empty RedBoot partition
# since the Sercomm upgrade tool checks for this trailer.
# http://www.nslu2-linux.org/wiki/Info/SercommRedBootTrailer
my @sercomm_redboot_trailer = (0x4573, 0x4372, 0x4d6f, 0x006d, 0x0001,
0x0400, 0x3170, 0x5895, 0x0010, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0001, 0x0000, 0x0000, 0x0000, 0x0003, 0x2300,
0x0063, 0x0000, 0x7320, 0x7245, 0x6f43, 0x6d4d);
# There's a 16 byte Sercomm trailer at the end of the flash. It is used
# by RedBoot to detect a Sercomm flash layout and to configure the
# Sercomm upgrade system.
# http://www.nslu2-linux.org/wiki/Info/SercommFlashTrailer
my @sercomm_flash_trailer = (0x0100, 0x0000, 0x6323, 0xf790, 0x5265,
0x4f63, 0x4d6d, 0xb400);
# Take $data, and pad it out to $total_len bytes, appending 0xff's.
sub padBytes {
my($data,$total_len) = @_;
# 0xFF is used to pad, as it's the erase value of the flash.
my($pad_char) = pack("C",0xff);
my($pad_len) = $total_len - length($data);
# A request for negative padding is indicative of a logic error ...
if (length($data) > $total_len) {
die sprintf("padBytes error: data (%d) is longer than total_len (%d)", length($data), $total_len);
}
return $data . ($pad_char x $pad_len);
}
# Return the next multiple of block_size larger than or equal to $data_len.
sub paddedSize {
my($data_len) = @_;
use integer;
return (($data_len - 1) / $block_size) * $block_size + $block_size;
}
# Return the number of block_size blocks required to hold $data_len.
sub numBlocks {
my($data_len) = @_;
use integer;
return (($data_len - 1) / $block_size) + 1;
}
# Pack the name, address, size and optional skip regions of a partition entry into binary form.
sub createPartitionEntry {
my($name, $flash_base, $size, $skips) = @_;
my $entry;
my($zero_long) = 0x0000;
# Pack the partition entry according to the format that RedBoot (and the MTD partition parsing code) requires.
$entry = pack("a16N5x212N2",$name,$flash_base,$zero_long,$size,$zero_long,$zero_long,$zero_long,$zero_long);
# Optionally put a skip header into the padding area.
if (defined $skips) {
my $i = scalar(@$skips);
foreach my $region (@$skips) {
substr($entry, -8 - 12*$i, 12) =
pack("a4N2", "skip", $region->{'offset'}, $region->{'size'});
$i--;
}
}
return $entry;
}
# Parse partition entry and return anon array ref [$name, $offset, $size, $skip] or return 0 on partition terminator.
sub parsePartitionEntry {
my($partition_entry) = @_;
my($entry_len) = 0x100;
length($partition_entry) eq $entry_len or die "parsePartitionEntry: partition entry length is not $entry_len!\n";
# Unpack the partition table entry, saving those values in which we are interested.
my($name, $flash_base, $size, $dummy_long, $padding, $skips);
($name, $flash_base, $dummy_long, $size, $dummy_long, $dummy_long, $padding, $dummy_long, $dummy_long) =
unpack("a16N5a212N2",$partition_entry);
# A partition entry starting with 0xFF terminates the table.
if (unpack("C", $name) eq 0xff) {
# %%% FIXME: This should only skip, not terminate. %%%
$debug and print "Found terminator for <FIS directory>\n";
return 0;
}
# Remove trailing nulls from the partition name.
$name =~ s/\000+//;
# Extract the skip regions out of the padding area.
$padding =~ s/^\000+//;
$padding =~ s/\000*skip(........)\000*/$1/g;
$padding =~ s/\000+$//;
# Store the skip regions in an array for later use.
while (length($padding)) {
my $region = {};
($region->{'offset'}, $region->{'size'}) =
unpack("N2", $padding);
$debug and printf("Found skip region at 0x%05X, size 0x%05X\n",
$region->{'offset'}, $region->{'size'});
push(@$skips, $region);
$padding = substr($padding,8);
}
return [$name, $flash_base - $flash_start, $size, $skips];
}
# Return partition table from data is one exists, otherwise return 0.
sub findPartitionTable {
my($data_buf) = @_;
unpack("a7", $data_buf) eq 'RedBoot' or return 0;
return substr($data_buf, 0, 0x1000)
}
# Parse partition table and return array of anonymous array references ([$name, $offset, $size, $skips], ...).
sub parsePartitionTable {
my($partition_table) = @_;
my(@partitions, $fields_ref);
my($entry_len) = 0x100;
my($partition_count) = 0;
# Loop through the fixed size partition table entries, and store the entries in @partitions.
# %%% FIXME: This doesn't handle the case of a completely full partition table. %%%
while ($fields_ref = parsePartitionEntry(substr($partition_table, $partition_count * $entry_len, $entry_len))) {
$debug and printf("Found <%s> at 0x%08X (%s)%s\n", $fields_ref->[0], $fields_ref->[1],
($fields_ref->[2] >= $block_size ?
sprintf("%d blocks", numBlocks($fields_ref->[2])) :
sprintf("0x%05X bytes", $fields_ref->[2])),
(defined $fields_ref->[3] ?
sprintf(" [%s]",
join(", ",
map { sprintf("0x%05X/0x%05X", $_->{'offset'},$_->{'size'}) }
@{$fields_ref->[3]})) :
""));
$partitions[$partition_count++] = $fields_ref;
}
return(@partitions);
}
# Create an empty jffs2 block.
sub jffs2Block {
return padBytes(pack("N3", 0x19852003, 0x0000000c, 0xf060dc98), $block_size);
}
# Write out $data to $filename,
sub writeOut {
my($data, $filename) = @_;
open FILE,">$filename" or die "Can't open file \"$filename\": $!\n";
if (defined($data)) { print FILE $data;}
close FILE or die "Can't close file \"$filename\": $!\n";
}
# Not used at the moment.
sub trailerData {
my($product_id) = 0x0001;
my($protocol_id) = 0x0000;
my($firmware_version) = 0x2325;
my($unknown1) = 0x90f7;
my($magic_number) = 'eRcOmM';
my($unknown2) = 0x00b9;
return pack("n4a6n",$product_id,$protocol_id,$firmware_version,$unknown1,$magic_number,$unknown2);
}
# Print the contents of the Sercomm RedBoot trailer.
sub printRedbootTrailer {
my($redboot_data) = @_;
my($correct_redboot_len) = 0x40000;
my($redboot_data_len) = length($redboot_data);
if ($redboot_data_len != $correct_redboot_len) {
printf("Redboot length (0x%08X) is not 0x%08X\n", $redboot_data_len, $correct_redboot_len);
return;
}
# The trailer is the last 80 bytes of the redboot partition.
my($redboot_trailer) = substr($redboot_data, -80);
writeOut($redboot_trailer, 'RedbootTrailer');
my($mac_addr0, $mac_addr1, $mac_addr2, $unknown, $prefix, $ver_ctrl, $down_ctrl, $hid, $hver, $prodid, $prodidmask,
$protid, $protidmask, $funcid, $funcidmask, $fver, $cseg, $csize, $postfix) =
unpack("n3Na7n2a32n10a7",$redboot_trailer);
printf("MAC address is %04X%04X%04X\n", $mac_addr0, $mac_addr1, $mac_addr2);
printf("unknown: %08X\n", $unknown);
printf("%s:%04X:%04X:%s\n", $prefix, $ver_ctrl, $down_ctrl, $postfix);
printf("VerControl: %04X\nDownControl: %04X\n", $ver_ctrl, $down_ctrl);
printf("hid: %04X %04X %04X %04X %04X %04X %04X %04X %04X %04X %04X %04X %04X %04X %04X %04X\n", unpack("n16", $hid));
printf("Hver: %04X\nProdID: %04X\nProtID: %04X\nFuncID: %04X\nFver: %04X\nCseg: %04X\nCsize: %04X\n",
$hver, $prodid, $protid, $funcid, $fver, $cseg, $csize);
}
# remove the optional Loader partition
sub removeOptionalLoader {
my($partitions_ref) = @_;
my $index;
my $count = 0;
map {
if (not defined $index) {
if ($_->{'name'} eq "Loader") {
$index = $count;
}
$count++;
}
} @$partitions_ref;
defined $index or die "Cannot find the Loader partition\n";
splice(@$partitions_ref, $index, 1);
# Set fixed offsets and sizes for Kernel and Ramdisk
map {
if ($_->{'name'} eq 'Kernel') {
$_->{'offset'} = $kernel_offset;
$_->{'size'} = $kernel_size;
$_->{'variable'} = 0;
}
if ($_->{'name'} eq 'Ramdisk') {
$_->{'offset'} = $ramdisk_offset;
}
} @$partitions_ref;
return;
}
# populate @partitions based on the firmware's partition table
sub spliceFirmwarePartitions {
my($firmware_buf, $partitions_ref) = @_;
# we know that partition table, if it exists, begins at start of 'FIS directory' and has max length 0x1000
my($partition_table);
map {
$_->{'name'} eq 'FIS directory' and
$partition_table = findPartitionTable(substr($firmware_buf, $_->{'offset'}, $_->{'size'}));
} @$partitions_ref;
# return 0 here if no partition table in FIS directory
return if not $partition_table;
my @new_partitions = parsePartitionTable($partition_table);
# Remove the optional second stage bootloader if it is not found in the FIS directory.
if (not grep { $_->[0] eq 'Loader' } @new_partitions) {
removeOptionalLoader($partitions_ref);
}
my($partition_count) = 0;
my($splice) = 0;
map {
# Skip pseudo partitions.
while (($partition_count < scalar(@$partitions_ref)) and
$partitions_ref->[$partition_count]->{'pseudo'}) {
$debug and printf("Skipped <%s> (pseudo partition)\n", $partitions_ref->[$partition_count]->{'name'});
$partition_count++;
}
# If we are in a variable area, and we haven't reached the end of it,
# then splice in another partition for use by the later code.
if ($splice and ($partitions_ref->[$partition_count]->{'name'} ne $_->[0])) {
$debug and printf("Splicing new partition <%s> before <%s>\n",
$_->[0], $partitions_ref->[$partition_count]->{'name'});
splice(@{$partitions_ref}, $partition_count, 0, ({'name' => "",'variable'=>1,'header'=>0}));
}
my $partition = $partitions_ref->[$partition_count];
# Variable partitions can be overridden by the real FIS directory
if ($partition->{'variable'}) {
# Only override the filename if the partition name is not set or doesn't match
if ($partition->{'name'} ne $_->[0]) {
if (length($partition->{'name'})) {
$debug and printf("Overwriting <%s> with <%s>\n",
$partitions_ref->[$partition_count]->{'name'}, $_->[0]);
}
$partition->{'name'} = $_->[0];
$partition->{'file'} = $_->[0];
}
# Set the offset, size and skips based on the real partition table
$partition->{'offset'} = $_->[1];
$partition->{'size'} = $_->[2];
$partition->{'skips'} = $_->[3];
$debug and printf("Locating <%s> at 0x%08X (%s)\n",
$partition->{'name'}, $partition->{'offset'},
($partition->{'size'} >= $block_size ?
sprintf("%d blocks", numBlocks($partition->{'size'})) :
sprintf("0x%05X bytes", $partition->{'size'})));
$splice = 1;
}
# Fixed partitions cannot be overridden
else {
($partition->{'name'} eq $_->[0]) or
die "Unexpected partition <",$_->[0],"> (expecting <",$partition->{'name'},">)\n";
$debug and printf("Locating <%s> at 0x%08X (%s)\n",
$partition->{'name'}, $partition->{'offset'},
($partition->{'size'} >= $block_size ?
sprintf("%d blocks", numBlocks($partition->{'size'})) :
sprintf("0x%05X bytes", $partition->{'size'})));
$splice = 0;
}
$partition_count++;
} @new_partitions;
return;
}
# Read in an 8MB firmware file, and store the data into @partitions.
# Note that the data is only stored in a partition if 'offset' and 'size' are defined,
# and it does not already have data stored in it.
sub readInFirmware {
my($filename, $partitions_ref) = @_;
my($firmware_buf);
open FILE,$filename or die "Can't find firmware image \"$filename\": $!\n";
read FILE,$firmware_buf,$flash_len or die "Can't read $flash_len bytes from \"$filename\": $!\n";
close FILE or die "Can't close \"$filename\": $!\n";
$debug and printf("Read 0x%08X bytes from \"%s\"\n", length($firmware_buf), $filename);
spliceFirmwarePartitions($firmware_buf, $partitions_ref);
# Read the parts of the firmware file into the partitions table.
map {
if (defined $_->{'offset'} and defined $_->{'size'}) {
if (defined $_->{'data'}) {
$debug and printf("Not overwriting data in <%s>\n", $_->{'name'});
}
else {
# Slurp up the data, based on whether a header and/or data is present or not
if ($_->{'header'}) {
# Read the length, and grab the data based on the length.
my($data_len) = unpack("N", substr($firmware_buf, $_->{'offset'}));
# A length of 0xFFFFFFFF means that the area is not initialised
if ($data_len != 0xFFFFFFFF) {
$debug and printf("Found header size of 0x%08X bytes for <%s>\n", $data_len, $_->{'name'});
$_->{'data'} = substr($firmware_buf, $_->{'offset'} + $_->{'header'}, $data_len);
}
}
elsif ($_->{'pseudo'} and not defined $_->{'file'} and
(substr($firmware_buf, $_->{'offset'}, $_->{'size'}) eq
(pack("C", 0xff) x $_->{'size'}))) {
$debug and printf("Skipping empty pseudo partition <%s>\n", $_->{'name'});
}
else {
# Grab the whole partition, using the maximum size.
$_->{'data'} = substr($firmware_buf, $_->{'offset'}, $_->{'size'});
}
# If skip regions are defined, remove them from the data.
if (defined $_->{'skips'}) {
my $removed = 0;
foreach my $region (@{$_->{'skips'}}) {
if (($region->{'offset'} > 0) or
not ($_->{'header'} > 0)) {
$debug and printf("Removing 0x%05X bytes from offset 0x%05X\n",
$region->{'size'}, $region->{'offset'});
$region->{'data'} = substr($_->{'data'}, $region->{'offset'} - $removed, $region->{'size'}, '');
}
$removed += $region->{'size'};
}
}
$quiet or defined $_->{'data'} and printf("Read %s into <%s>\n",
(length($_->{'data'}) >= $block_size ?
sprintf("%d blocks", numBlocks(length($_->{'data'}))) :
sprintf("0x%05X bytes", length($_->{'data'}))), $_->{'name'});
}
}
} @$partitions_ref;
}
# Write the partition data stored in memory out into the files associated with each.
sub writeOutFirmwareParts {
my(@partitions) = @_;
# Write out the parts of the firmware file.
map {
# We can only write if 'data' and 'file' are defined.
if (defined $_->{'file'} and defined $_->{'data'} and length($_->{'data'})) {
writeOut($_->{'data'}, $_->{'file'});
$quiet or printf("Wrote 0x%08X bytes from <%s> into \"%s\"\n",
length($_->{'data'}), $_->{'name'}, $_->{'file'});
}
else {
$debug and printf("Skipping <%s> (%s)\n", $_->{'name'},
(not defined $_->{'file'}) ?
"no filename specified" :
"no data to write");
}
} @partitions;
return;
}
# Read in the partition data from the files associated with each and store in memory.
sub readInFirmwareParts {
my(@partitions) = (@_);
undef $/; # we want to slurp
map {
my $file = $_->{'file'};
if (defined $file) {
open FILE,$file or die "Can't find firmware part \"$file\": $!\n";
# Slurp in the data
$_->{'data'} = <FILE>;
# close the file
close FILE or die "Can't close file \"$file\": $!\n";
# Optionally byteswap the data
if ($_->{'byteswap'}) {
# Byte swap the data (which has to be padded to a multiple of 4 bytes).
$_->{'data'} = pack("N*", unpack("V*", $_->{'data'}.pack("CCC", 0)));
}
# Keep track of the actual size.
my $size;
if ($_->{'header'}) {
if ($_->{'pseudo'}) {
$size = $_->{'header'} + length($_->{'data'});
}
else {
$size = paddedSize($_->{'header'} + length($_->{'data'}));
}
}
elsif (not $_->{'pseudo'}) {
$size = paddedSize(length($_->{'data'}));
}
else {
$size = length($_->{'data'});
}
# Check to make sure the file contents are not too large.
if (defined $_->{'size'} and ($size > $_->{'size'})) {
die sprintf("Ran out of flash space in <%s> - %s too large.\n", $_->{'name'},
sprintf("0x%05X bytes", ($size - $_->{'size'})));
}
# If the partition does not have a fixed size, the calculate the size.
if (not defined $_->{'size'}) {
$_->{'size'} = $size;
}
# Keep the user appraised ...
$quiet or printf("Read 0x%08X bytes from \"%s\" into <%s> (%s / %s)%s\n",
length($_->{'data'}), $_->{'file'}, $_->{'name'},
($size >= $block_size ?
sprintf("%d blocks", numBlocks($size)) :
sprintf("0x%05X bytes", $size)),
($_->{'size'} >= $block_size ?
sprintf("%d blocks", numBlocks($_->{'size'})) :
sprintf("0x%05X bytes", $_->{'size'})),
($_->{'byteswap'} ? " (byte-swapped)" : ""));
}
} @partitions;
return;
}
# layoutPartitions : this function must be ugly - it needs to verify RedBoot, SysConf, Kernel, Ramdisk, and
# FIS directory partitions exist, are in the correct order, and do not have more data than can fit in
# their lengths (fixed for all but Ramdisk, which has a minimum length of one block).
# If Rootdisk and/or Userdisk exist, it must also verify that their block padded lengths are not
# too great for the available space.
# input : an array of hashes, some of which are populated with data
# output: same reference with start and size (partition not data) also populated. this populated structure
# can then be passed to buildPartitionTable() to generate the actual partition table data
sub layoutPartitions {
my(@partitions) = @_;
# Find the kernel partition, and save a pointer to it for later use
my $kernel;
map { ($_->{'name'} eq "Kernel") && ($kernel = $_); } @partitions;
$kernel or die "Couldn't find the kernel partition\n";
# Find the last variable size partition, and save a pointer to it for later use
my $lastdisk;
my $directory_offset;
my $curdisk = $partitions[0];
map {
if (not defined $lastdisk) {
if ($_->{'name'} eq "FIS directory") {
$lastdisk = $curdisk;
$directory_offset = $_->{'offset'};
}
else {
$curdisk = $_;
}
}
} @partitions;
$lastdisk or die "Couldn't find the last variable size partition\n";
$debug and printf("Last variable size partition is <%s>\n", $lastdisk->{'name'});
#
# here we go through the $partitions array ref and fill in all the values
#
# This points to where the next partition should be placed.
my $pointer = $flash_start;
map {
$debug and printf("Pointer is 0x%08X\n", $pointer);
# Determine the start and offset of the current partition.
if (defined $_->{'offset'}) {
$_->{'start'} = $flash_start + $_->{'offset'};
# Check for running past the defined start of the partition.
if (($pointer > $_->{'start'}) and not $_->{'pseudo'}) {
die sprintf("Ran out of flash space before <%s> - %s too large.\n", $_->{'name'},
sprintf("0x%05X bytes", ($pointer - $_->{'start'})));
}
}
# If offset is not defined, then calculate it.
else {
$_->{'start'} = $pointer;
$_->{'offset'} = $_->{'start'} - $flash_start;
}
my $size = defined $_->{'data'} ? length($_->{'data'}) : 0;
# Add skip regions for the partitions with headers.
if ($_->{'header'} > 0) {
# Define the skip region for the initial Sercomm header.
push(@{$_->{'skips'}},
{ 'offset' => 0, 'size' => $_->{'header'}, 'data' => undef });
# Allow for the Sercomm header to be prepended to the data.
$size += $_->{'header'};
# Determine if the partition overlaps the ramdisk boundary.
if (($_->{'offset'} < $ramdisk_offset) and
(($_->{'offset'} + $size) > $ramdisk_offset)) {
# Define the skip region for the inline Sercomm header.
push(@{$_->{'skips'}},
{ 'offset' => ($ramdisk_offset - $_->{'offset'}), 'size' => 16,
'data' => pack("N4", $block_size) });
# Allow for the Sercomm header to be inserted in the data.
$size += 16;
}
}
# Partitions without headers cannot have skip regions.
elsif (($_->{'offset'} <= $ramdisk_offset) and
(($_->{'offset'} + $size) > $ramdisk_offset)) {
# Pad the kernel until it extends past the ramdisk offset.
push(@{$kernel->{'skips'}},
{ 'offset' => ($ramdisk_offset - $kernel->{'offset'}), 'size' => 16,
'data' => pack("N4", $block_size) });
$kernel->{'size'} = $ramdisk_offset - $kernel->{'offset'} + $block_size;
$kernel->{'data'} = padBytes($kernel->{'data'},
$kernel->{'size'} - $kernel->{'header'} - 16);
$_->{'offset'} = $ramdisk_offset + $block_size;
$_->{'start'} = $flash_start + $_->{'offset'};
$pointer = $_->{'start'};
$debug and printf("Extending kernel partition past ramdisk offset.\n");
}
# If this is the last variable size partition, then fill the rest of the space.
if ($_->{'name'} eq $lastdisk->{'name'}) {
$_->{'size'} = paddedSize($directory_offset + $flash_start - $pointer);
$debug and printf("Padding last variable partition <%s> to 0x%08X bytes\n", $_->{'name'}, $_->{'size'});
}
die sprintf("Partition size not defined in <%s>.\n", $_->{'name'})
unless defined $_->{'size'};
# Extend to another block if required.
if ($size > $_->{'size'}) {
if ($_->{'name'} eq $lastdisk->{'name'}) {
die sprintf("Ran out of flash space in <%s> - %s too large.\n", $_->{'name'},
sprintf("0x%05X bytes", ($size - $_->{'size'})));
}
$_->{'size'} = $size;
printf("Extending partition <%s> to 0x%08X bytes\n", $_->{'name'}, $_->{'size'});
}
# Keep the user appraised ...
$debug and printf("Allocated <%s> from 0x%08X to 0x%08X (%s / %s)\n",
$_->{'name'}, $_->{'start'}, $_->{'start'} + $_->{'size'},
($size >= $block_size ?
sprintf("%d blocks", numBlocks($size)) :
sprintf("0x%05X bytes", $size)),
($_->{'size'} >= $block_size ?
sprintf("%d blocks", numBlocks($_->{'size'})) :
sprintf("0x%05X bytes", $_->{'size'})));
# Check to make sure we have not run out of room.
if (($_->{'start'} + $_->{'size'}) > ($flash_start + $flash_len)) {
die "Ran out of flash space in <", $_->{'name'}, ">\n";
}
$debug and printf("Moving pointer from 0x%08X to 0x%08X (0x%08X + 0x%08X)\n",
$pointer, paddedSize($_->{'start'} + $_->{'size'}),
$_->{'start'}, $_->{'size'});
# Move the pointer up, in preparation for the next partition.
$pointer = paddedSize($_->{'start'} + $_->{'size'});
} @partitions;
return;
}
sub buildPartitionTable {
my(@partitions) = @_;
my($flash_start) = 0x50000000;
my($partition_data) = '';
map {
# Collate the partition data for all known partitions.
if (not $_->{'pseudo'} and defined $_->{'offset'} and defined $_->{'size'}) {
# Pack and append the binary table entry for this partition.
$partition_data .= createPartitionEntry($_->{'name'}, $_->{'offset'} + $flash_start,
$_->{'size'}, $_->{'skips'});
# If this is the FIS directory, then write the partition table data into it.
if ($_->{'name'} eq "FIS directory") {
# Explicitly terminate the partition data.
$partition_data .= pack("C",0xff) x 0x100;
$_->{'data'} = padBytes($partition_data, $_->{'size'});
}
my $size = length($_->{'data'});
# Keep the user appraised ...
$debug and printf("Table entry <%s> from 0x%08X to 0x%08X (%s / %s)%s\n",
$_->{'name'}, $_->{'start'}, $_->{'start'} + $_->{'size'},
($size >= $block_size ?
sprintf("%d blocks", numBlocks($size)) :
sprintf("0x%05X bytes", $size)),
($_->{'size'} >= $block_size ?
sprintf("%d blocks", numBlocks($_->{'size'})) :
sprintf("0x%05X bytes", $_->{'size'})),
(defined $_->{'skips'} ?
sprintf("\nTable entry <%s> skip %s", $_->{'name'},
join(", ",
map { sprintf("0x%08X to 0x%08X", $_->{'offset'},
$_->{'offset'} + $_->{'size'} - 1) }
@{$_->{'skips'}})) :
"")
);
}
else {
$debug and print "No table entry required for <", $_->{'name'}, ">\n";
}
} @partitions;
return;
}
sub writeOutFirmware {
my($filename, @partitions) = @_;
# Clear the image to start.
my $image_buf = "";
map {
# We can only write a partition if it has an offset, a size, and some data to write.
if (defined $_->{'offset'} and defined $_->{'size'} and defined $_->{'data'}) {
# Keep track of the end of the image.
my $end_point = length($image_buf);
# If the next partition is well past the end of the current image, then pad it.
if ($_->{'offset'} > $end_point) {
$image_buf .= padBytes("", $_->{'offset'} - $end_point);
$quiet or printf("Padded %s before <%s> in \"%s\"\n",
((length($image_buf) - $end_point) >= $block_size ?
sprintf("%d blocks", numBlocks(length($image_buf) - $end_point)) :
sprintf("0x%05X bytes", length($image_buf) - $end_point)),
$_->{'name'}, $filename);
}
# If the next parition is before the end of the current image, then rewind.
elsif ($_->{'offset'} < $end_point) {
$debug and printf("Rewound %s before <%s> in \"%s\"\n",
(($end_point - $_->{'offset'}) >= $block_size ?
sprintf("%d blocks", numBlocks($end_point - $_->{'offset'})) :
sprintf("0x%05X bytes", $end_point - $_->{'offset'})),
$_->{'name'}, $filename);
# if (($end_point - $_->{'offset'}) >= $block_size) {
# die "Allocation error: rewound a full block or more ...\n";
# }
}
# If skip regions are defined, add them to the data.
if (defined $_->{'skips'}) {
my $added = 0;
foreach my $region (@{$_->{'skips'}}) {
if (($region->{'offset'} > 0) or
not ($_->{'header'} > 0)) {
$debug and printf("Inserted 0x%05X bytes (at offset 0x%05X) into <%s>\n",
$region->{'size'}, $region->{'offset'}, $_->{'name'});
substr($_->{'data'},
$region->{'offset'} + $added - $_->{'header'},
0, $region->{'data'});
$added += $region->{'size'};
}
}
}
# Splice the data into the image at the appropriate place, padding as required.
substr($image_buf, $_->{'offset'}, $_->{'size'},
$_->{'header'} ?
padBytes(pack("N4",length($_->{'data'})).$_->{'data'}, $_->{'size'}) :
padBytes($_->{'data'}, $_->{'size'}));
# Keep the user appraised ...
$quiet or printf("Wrote %s (0x%08X to 0x%08X) from <%s> into \"%s\"\n",
($_->{'size'} >= $block_size ?
sprintf("%2d blocks", numBlocks($_->{'size'})) :
sprintf("0x%05X bytes", $_->{'size'})),
$_->{'offset'}, $_->{'offset'}+$_->{'size'}, $_->{'name'}, $filename);
}
# If we are not able to write a partition, then give debug information about why.
else {
$debug and printf("Skipping <%s> (%s)\n", $_->{'name'},
(not defined $_->{'offset'}) ? "no offset defined" :
((not defined $_->{'size'}) ? "no size defined" :
"no data available"));
}
} @partitions;
# Write the image to the specified file.
writeOut($image_buf, $filename);
return;
}
# checkPartitionTable: sanity check partition table - for testing but might evolve into setting @partitions
# so that we can write out jffs2 partitions from a read image
# currently not nearly paranoid enough
sub checkPartitionTable {
my($data) = @_;
my($pointer) = 0;
my($entry);
my($name, $flash_base, $size, $done, $dummy_long, $padding);
do {
$entry = substr($data, $pointer, 0x100);
($name,$flash_base,$dummy_long,$size,$dummy_long,$dummy_long,$padding,$dummy_long,$dummy_long) = unpack("a16N5x212N2",$entry);
$name =~ s/\0//g;
$debug and printf("pointer: %d\tname: %s%sflash_base: 0x%08X\tsize: 0x%08X\n",
$pointer, $name, (" " x (16 - length($name))), $flash_base, $size);
$pointer += 0x100;
$debug and printf("terminator: 0x%08X\n", unpack("C", substr($data, $pointer, 1)));
if (unpack("C", substr($data, $pointer, 1)) eq 0xff) {
$done = 1;
}
} until $done;
}
sub printPartitions {
my(@partitions) = @_;
my($offset, $size, $skips);
map {
# defined $_->{'size'} ? $size = $_->{'size'} : $size = undef;
if (defined $_->{'size'}) {
$size = $_->{'size'};
}
else {
$size = undef;
}
if (defined $_->{'offset'}) {
$offset = $_->{'offset'};
}
else {
$offset = undef;
}
if (defined $_->{'skips'}) {
$skips = $_->{'skips'};
}
else {
$skips = undef;
}
printf("%s%s", $_->{'name'}, (" " x (16 - length($_->{'name'}))));
if (defined $offset) { printf("0x%08X\t", $offset); } else { printf("(undefined)\t"); };
if (defined $size) { printf("0x%08X", $size); } else { printf("(undefined)"); };
if (defined $skips) {
printf("\t[%s]",
join(", ",
map { sprintf("0x%05X/0x%05X", $_->{'offset'}, $_->{'size'}); }
@$skips));
}
printf("\n");
} @partitions;
}
sub defaultPartitions {
return ({'name'=>'RedBoot', 'file'=>'RedBoot',
'offset'=>0x00000000, 'size'=>0x00040000,
'variable'=>0, 'header'=>0, 'pseudo'=>0, 'data'=>undef, 'byteswap'=>0},
{'name'=>'EthAddr', 'file'=>undef,
'offset'=>0x0003ffb0, 'size'=>0x00000006,
'variable'=>0, 'header'=>0, 'pseudo'=>1, 'data'=>undef, 'byteswap'=>0},
{'name'=>'SysConf', 'file'=>'SysConf',
'offset'=>0x00040000, 'size'=>0x00020000,
'variable'=>0, 'header'=>0, 'pseudo'=>0, 'data'=>undef, 'byteswap'=>0},
{'name'=>'Loader', 'file'=>'apex.bin',
'offset'=>undef, 'size'=>undef,
'variable'=>1, 'header'=>16, 'pseudo'=>0, 'data'=>undef, 'byteswap'=>0},
{'name'=>'Kernel', 'file'=>'vmlinuz',
'offset'=>undef, 'size'=>undef,
'variable'=>1, 'header'=>16, 'pseudo'=>0, 'data'=>undef, 'byteswap'=>0},
{'name'=>'Ramdisk', 'file'=>'ramdisk.gz',
'offset'=>undef, 'size'=>undef,
'variable'=>1, 'header'=>16, 'pseudo'=>0, 'data'=>undef, 'byteswap'=>0},
{'name'=>'FIS directory', 'file'=>undef,
'offset'=>0x007e0000, 'size'=>0x00020000,
'variable'=>0, 'header'=>0, 'pseudo'=>0, 'data'=>undef, 'byteswap'=>0},
{'name'=>'Loader config', 'file'=>undef,
'offset'=>0x007f8000, 'size'=>0x00004000,
'variable'=>0, 'header'=>0, 'pseudo'=>1, 'data'=>undef, 'byteswap'=>0},
{'name'=>'Microcode', 'file'=>'NPE-B',
'offset'=>0x007fc000, 'size'=>0x00003fe0,
'variable'=>0, 'header'=>16, 'pseudo'=>1, 'data'=>undef, 'byteswap'=>0},
{'name'=>'Trailer', 'file'=>'Trailer',
'offset'=>0x007ffff0, 'size'=>0x00000010,
'variable'=>0, 'header'=>0, 'pseudo'=>1, 'data'=>undef, 'byteswap'=>0});
}
# Main routine starts here ...
my($unpack, $pack, $little, $fatflash, $input, $output, $redboot);
my($kernel, $sysconf, $ramdisk, $fisdir);
my($microcode, $trailer, $ethaddr, $loader);
END {
# Remove temporary files
for my $file (@cleanup) {
unlink $file;
}
}
if (!GetOptions("d|debug" => \$debug,
"q|quiet" => \$quiet,
"u|unpack" => \$unpack,
"p|pack" => \$pack,
"l|little" => \$little,
"F|fatflash" => \$fatflash,
"i|input=s" => \$input,
"o|output=s" => \$output,
"b|redboot=s" => \$redboot,
"k|kernel=s" => \$kernel,
"s|sysconf=s" => \$sysconf,
"r|ramdisk=s" => \$ramdisk,
"f|fisdir=s" => \$fisdir,
"m|microcode=s" => \$microcode,
"t|trailer=s" => \$trailer,
"e|ethaddr=s" => \$ethaddr,
"L|loader=s" => \$loader,
) or (not defined $pack and not defined $unpack)) {
print "Usage: slugimage <options>\n";
print "\n";
print " [-d|--debug] Turn on debugging output\n";
print " [-q|--quiet] Turn off status messages\n";
print " [-u|--unpack] Unpack a firmware image\n";
print " [-p|--pack] Pack a firmware image\n";
print " [-l|--little] Convert Kernel and Ramdisk to little-endian\n";
print " [-F|--fatflash] Generate an image for 16MB flash\n";
print " [-i|--input] <file> Input firmware image filename\n";
print " [-o|--output] <file> Output firmware image filename\n";
print " [-b|--redboot] <file> Input/Output RedBoot filename\n";
print " [-s|--sysconf] <file> Input/Output SysConf filename\n";
print " [-L|--loader] <file> Second stage boot loader filename\n";
print " [-k|--kernel] <file> Input/Ouptut Kernel filename\n";
print " [-r|--ramdisk] <file> Input/Output Ramdisk filename(s)\n";
print " [-f|--fisdir] <file> Input/Output FIS directory filename\n";
print " [-m|--microcode] <file> Input/Output Microcode filename\n";
print " [-t|--trailer] <file> Input/Output Trailer filename\n";
print " [-e|--ethaddr] <AABBCCDDEEFF> Set the Ethernet address\n";
# %%% TODO %%% Document --ramdisk syntax
exit 1;
}
my(@partitions) = defaultPartitions();
if ($pack) {
die "Output filename must be specified\n" unless defined $output;
# If we're creating an image and no RedBoot, SysConf partition is
# explicitly specified, simply write an empty one as the upgrade tools
# don't touch RedBoot and SysConf anyway. If no Trailer is specified,
# put in one.
if (not defined $redboot and not -e "RedBoot") {
$redboot = tmpnam();
open TMP, ">$redboot" or die "Cannot open file $redboot: $!";
push @cleanup, $redboot;
# The RedBoot partition is 256 * 1024 = 262144; the trailer we add
# is 70 bytes.
print TMP "\0"x(262144-70);
# Upgrade tools check for an appropriate Sercomm trailer.
for my $i (@sercomm_redboot_trailer) {
print TMP pack "S", $i;
}
close TMP;
}
if (not defined $sysconf and not -e "SysConf") {
$sysconf = tmpnam();
open TMP, ">$sysconf" or die "Cannot open file $sysconf: $!";
push @cleanup, $sysconf;
# The SysConf partition is 128 * 1024 = 131072
print TMP "\0"x131072;
close TMP;
}
if (not defined $trailer and not -e "Trailer") {
$trailer = tmpnam();
open TMP, ">$trailer" or die "Cannot open file $trailer: $!";
push @cleanup, $trailer;
for my $i (@sercomm_flash_trailer) {
print TMP pack "S", $i;
}
close TMP;
}
# If the microcode was not specified, then don't complain that it's missing.
if (not defined $microcode and not -e "NPE-B") {
map { ($_->{'name'} eq 'Microcode') && ($_->{'file'} = undef); } @partitions;
}
}
# Go through the partition options, and set the names and files in @partitions
if (defined $redboot) { map { ($_->{'name'} eq 'RedBoot') && ($_->{'file'} = $redboot); } @partitions; }
if (defined $sysconf) { map { ($_->{'name'} eq 'SysConf') && ($_->{'file'} = $sysconf); } @partitions; }
if (defined $loader) { map { ($_->{'name'} eq 'Loader') && ($_->{'file'} = $loader); } @partitions; }
if (defined $kernel) { map { ($_->{'name'} eq 'Kernel') && ($_->{'file'} = $kernel); } @partitions; }
if (defined $fisdir) { map { ($_->{'name'} eq 'FIS directory') && ($_->{'file'} = $fisdir); } @partitions; }
if (defined $microcode) { map { ($_->{'name'} eq 'Microcode') && ($_->{'file'} = $microcode); } @partitions; }
if (defined $trailer) { map { ($_->{'name'} eq 'Trailer') && ($_->{'file'} = $trailer); } @partitions; }
if (defined $little) {
map {
if (($_->{'name'} eq 'Loader') or
($_->{'name'} eq 'Kernel') or
($_->{'name'} eq 'Ramdisk')) {
$_->{'byteswap'} = 1;
}
} @partitions;
}
if (defined $fatflash) {
$flash_len = 0x01000000;
map {
if (($_->{'name'} eq 'FIS directory') or
($_->{'name'} eq 'Loader config') or
($_->{'name'} eq 'Microcode') or
($_->{'name'} eq 'Trailer')) {
$_->{'offset'} += 0x00800000;
}
} @partitions;
}
if (defined $ethaddr) {
map {
if ($_->{'name'} eq 'EthAddr') {
$ethaddr =~ s/://g;
if (($ethaddr !~ m/^[0-9A-Fa-f]+$/) or (length($ethaddr) != 12)) {
die "Invalid ethernet address specification: '".$ethaddr."'\n";
}
$_->{'data'} = pack("H12", $ethaddr);
}
} @partitions;
}
if (defined $ramdisk) {
# A single filename is used for the ramdisk filename
if ($ramdisk !~ m/[:,]/) {
map { ($_->{'name'} eq 'Ramdisk') && ($_->{'file'} = $ramdisk); } @partitions;
}
# otherwise, it's a list of name:file mappings
else {
my @mappings = split(',', $ramdisk);
# Find the index of the Ramdisk entry
my $index;
my $count = 0;
map {
if (not defined $index) {
if ($_->{'name'} eq "Ramdisk") {
$index = $count;
}
$count++;
}
} @partitions;
defined $index or die "Cannot find the Ramdisk partition\n";
# Replace the Ramdisk entry with the new mappings
splice(@partitions, $index, 1, map {
# Preserve the information from the ramdisk entry
my %entry = %{$partitions[$index]};
# Parse the mapping
($_ =~ m/^([^:]+):([^:]+)(:([^:]+))?$/) or die "Invalid syntax in --ramdisk\n";
$entry{'name'} = $1; $entry{'file'} = $2; my $size = $4;
# If the mapping is not for the ramdisk, then undefine its attributes
if ($entry{'name'} ne 'Ramdisk') {
$entry{'offset'} = undef;
$entry{'size'} = undef;
$entry{'variable'} = 1;
$entry{'header'} = 0;
$entry{'pseudo'} = 0;
$entry{'data'} = undef;
$entry{'byteswap'} = 0;
}
# Support specification of the number of blocks for empty jffs2
if ($entry{'file'} =~ m/^[0-9]+$/) {
$size = $entry{'file'};
$entry{'file'} = undef;
}
# If the user has specified a size, then respect their wishes
if (defined $size) {
$entry{'size'} = $size * $block_size;
# Create an empty partition of the requested size.
$entry{'data'} = padBytes("", $entry{'size'} - $entry{'header'});
}
\%entry;
} @mappings);
}
}
# Read in the firmware image
if ($input) {
if ($debug) {
print "Initial partition map:\n";
printPartitions(@partitions);
}
my $result = readInFirmware($input, \@partitions);
if ($debug) {
print "After reading firmware:\n";
printPartitions(@partitions);
}
}
# Unpack the firmware if requested
if ($unpack) {
die "Input filename must be specified\n" unless defined $input;
# map {
# ($_->{'name'} eq 'FIS directory') and @partitions = checkPartitionTable($_->{'data'});
# } @partitions;
writeOutFirmwareParts(@partitions);
}
# Pack the firmware if requested
if ($pack) {
if (!defined $loader) {
removeOptionalLoader(\@partitions);
}
if ($debug) {
print "Initial partition map:\n";
printPartitions(@partitions);
}
my $result = readInFirmwareParts(@partitions);
if ($debug) {
print "after readInFirmwareParts():\n";
printPartitions(@partitions);
# map {
# ($_->{'name'} eq 'RedBoot') && (printRedbootTrailer($_->{'data'}));
# } @partitions;
}
layoutPartitions(@partitions);
if ($debug) {
print "after layoutPartitions():\n";
printPartitions(@partitions);
}
buildPartitionTable(@partitions);
if ($debug) {
print "after buildPartitionTable():\n";
printPartitions(@partitions);
# my($lastblock);
# map {
# if ($_->{'name'} eq 'FIS directory') {
# $lastblock = $_->{'data'};
# }
# } @partitions;
# print "checkPartitionTable():\n";
# checkPartitionTable($lastblock);
}
writeOutFirmware($output, @partitions);
}
exit 0;
Jump to Line
Something went wrong with that request. Please try again.