diff options
Diffstat (limited to 'perl-install/resize_fat')
| -rw-r--r-- | perl-install/resize_fat/.cvsignore | 5 | ||||
| -rw-r--r-- | perl-install/resize_fat/Makefile | 10 | ||||
| -rw-r--r-- | perl-install/resize_fat/Makefile.PL | 13 | ||||
| -rw-r--r-- | perl-install/resize_fat/README | 8 | ||||
| -rw-r--r-- | perl-install/resize_fat/any.pm | 123 | ||||
| -rw-r--r-- | perl-install/resize_fat/boot_sector.pm | 110 | ||||
| -rw-r--r-- | perl-install/resize_fat/c_rewritten.pm | 14 | ||||
| -rw-r--r-- | perl-install/resize_fat/c_rewritten.xs | 259 | ||||
| -rw-r--r-- | perl-install/resize_fat/dir_entry.pm | 77 | ||||
| -rw-r--r-- | perl-install/resize_fat/directory.pm | 79 | ||||
| -rw-r--r-- | perl-install/resize_fat/fat.pm | 138 | ||||
| -rw-r--r-- | perl-install/resize_fat/info_sector.pm | 37 | ||||
| -rw-r--r-- | perl-install/resize_fat/io.pm | 71 | ||||
| -rw-r--r-- | perl-install/resize_fat/main.pm | 186 |
14 files changed, 0 insertions, 1130 deletions
diff --git a/perl-install/resize_fat/.cvsignore b/perl-install/resize_fat/.cvsignore deleted file mode 100644 index 3001c7424..000000000 --- a/perl-install/resize_fat/.cvsignore +++ /dev/null @@ -1,5 +0,0 @@ -blib -pm_to_blib -Makefile_c -c_rewritten.c -c_rewritten.bs diff --git a/perl-install/resize_fat/Makefile b/perl-install/resize_fat/Makefile deleted file mode 100644 index 9078b361a..000000000 --- a/perl-install/resize_fat/Makefile +++ /dev/null @@ -1,10 +0,0 @@ -.PHONY: clean - -c_rewritten: %: %.xs - test -e Makefile_c || perl Makefile.PL - $(MAKE) -f Makefile_c LD_RUN_PATH= || $(MAKE) -f Makefile_c LD_RUN_PATH= - rm -f ../auto/resize_fat ; ln -s ../resize_fat/blib/arch/auto ../auto/resize_fat - -clean: - test ! -e Makefile_c || $(MAKE) -f Makefile_c clean - rm -f *~ *.o diff --git a/perl-install/resize_fat/Makefile.PL b/perl-install/resize_fat/Makefile.PL deleted file mode 100644 index 712f4e395..000000000 --- a/perl-install/resize_fat/Makefile.PL +++ /dev/null @@ -1,13 +0,0 @@ -use ExtUtils::MakeMaker; -# See lib/ExtUtils/MakeMaker.pm for details of how to influence -# the contents of the Makefile that is written. - -WriteMakefile( - 'MAKEFILE' => 'Makefile_c', - 'NAME' => 'c_rewritten', - 'OPTIMIZE' => '-Os', - 'VERSION_FROM' => 'c_rewritten.pm', # finds $VERSION - 'LIBS' => '', # e.g., '-lm' - 'DEFINE' => '', # e.g., '-DHAVE_SOMETHING' - 'INC' => '', # e.g., '-I/usr/include/other' -); diff --git a/perl-install/resize_fat/README b/perl-install/resize_fat/README deleted file mode 100644 index 12b64dea9..000000000 --- a/perl-install/resize_fat/README +++ /dev/null @@ -1,8 +0,0 @@ -TODO: - -resize_fat::fat::update($fs) should be called before doing undoable things -(before the sync in construct_dir_tree) - -BUGS: -no known bugs :) -if you found one, please mail pixel@mandrakesoft.com !! diff --git a/perl-install/resize_fat/any.pm b/perl-install/resize_fat/any.pm deleted file mode 100644 index f811e7159..000000000 --- a/perl-install/resize_fat/any.pm +++ /dev/null @@ -1,123 +0,0 @@ -package resize_fat::any; # $Id$ - -use diagnostics; -use strict; -use vars qw($FREE $FILE $DIRECTORY $UNMOVEABLE); - -use common; -use resize_fat::fat; -use resize_fat::directory; -use resize_fat::dir_entry; -use resize_fat::c_rewritten; - - -$FREE = 0; -$FILE = 1; -$DIRECTORY = 2; -$UNMOVEABLE = 8; - - -1; - - -#- returns the number of clusters for a given filesystem type -sub min_cluster_count($) { - my ($fs) = @_; - (1 << $ {{ FAT16 => 12, FAT32 => 12 }}{$fs->{fs_type}}) - 12; -} -sub max_cluster_count($) { - my ($fs) = @_; - (1 << $ {{ FAT16 => 16, FAT32 => 28 }}{$fs->{fs_type}}) - 11; -} - - - -#- patch to get the function last_used that return the last used cluster of a fs. -sub last_used($) { - my ($fs) = @_; - - #- count in negative so absolute value count back to 2. - foreach (-($fs->{nb_clusters}+1)..-2) { return -$_ if resize_fat::c_rewritten::flag(-$_) } - die "any: empty FAT table of $fs->{nb_clusters} clusters"; -} -#- patch to get the function last_unmoveable that return the last unmoveable cluster of a fs. -sub last_unmoveable($) { - my ($fs) = @_; - - #- count in negative so absolute value count back to 2. - foreach (-($fs->{nb_clusters}+1)..-2) { return -$_ if 0x8 & resize_fat::c_rewritten::flag(-$_) } - - #- Oh at this point there are no unmoveable blocks! - 2; -} - -#- calculates the minimum size of a partition, in physical sectors -sub min_size($) { - my ($fs) = @_; - my $count = $fs->{clusters}{count}; - - #- directories are both in `used' and `dirs', so are counted twice - #- It's done on purpose since we're moving all directories. So at the worse - #- moment, 2 directories are there, but that way nothing wrong can happen :) - my $min_cluster_count = max(2 + $count->{used} + $count->{bad} + $count->{dirs}, min_cluster_count($fs)); - $min_cluster_count = max($min_cluster_count, last_unmoveable($fs)); - - my $size = $min_cluster_count * divide($fs->{cluster_size}, $SECTORSIZE) + - divide($fs->{cluster_offset}, $SECTORSIZE) + - 64*1024*1024 / $SECTORSIZE; #- help with such more sectors (ie 64Mb). - - #- help zindozs again with 512Mb+ at least else partition is ignored. - if ($resize_fat::isFAT32) { - $size = max($size, 524*1024*1024 / $SECTORSIZE); - } - $size; - -} -#- calculates the maximum size of a partition, in physical sectors -sub max_size($) { - my ($fs) = @_; - - my $max_cluster_count = min($fs->{nb_fat_entries} - 2, max_cluster_count($fs)); - - $max_cluster_count * divide($fs->{cluster_size}, $SECTORSIZE) + - divide($fs->{cluster_offset}, $SECTORSIZE); -} -#- calculates used size in order to avoid modifying anything. -sub used_size($) { - my ($fs) = @_; - - my $used_cluster_count = max(last_used($fs), min_cluster_count($fs)); - - $used_cluster_count * divide($fs->{cluster_size}, $SECTORSIZE) + - divide($fs->{cluster_offset}, $SECTORSIZE); -} - -#- fills in fat_flag_map in c_rewritten. -#- Each FAT entry is flagged as either FREE, FILE or DIRECTORY. -sub flag_clusters { - my ($fs) = @_; - my ($cluster, $curr_dir_name, $entry, $type, $nb_dirs); - - my $f = sub { - ($curr_dir_name, $entry) = @_; - $cluster = resize_fat::dir_entry::get_cluster($entry); - - if (resize_fat::dir_entry::is_file($entry)) { - $type = $FILE; - $type |= $UNMOVEABLE if resize_fat::dir_entry::is_unmoveable($entry); - } elsif (resize_fat::dir_entry::is_directory($entry)) { - $type = $DIRECTORY; - } else { return } - - my $nb = resize_fat::c_rewritten::checkFat($cluster, $type, "$curr_dir_name/$entry->{name}"); - print "resize_fat:flag_clusters: check fat returned $nb of type $type for $curr_dir_name/$entry->{name}\n"; - $nb_dirs += $nb if $type == $DIRECTORY; - 0; - }; - - #- this must call allocate_fat_flag that zeroes the buffer allocated. - resize_fat::c_rewritten::allocate_fat_flag($fs->{nb_clusters} + 2); - - resize_fat::directory::traverse_all($fs, $f); - $fs->{clusters}{count}{dirs} = $nb_dirs; -} diff --git a/perl-install/resize_fat/boot_sector.pm b/perl-install/resize_fat/boot_sector.pm deleted file mode 100644 index c87328637..000000000 --- a/perl-install/resize_fat/boot_sector.pm +++ /dev/null @@ -1,110 +0,0 @@ -package resize_fat::boot_sector; # $Id$ - -use diagnostics; -use strict; - -use common; -use resize_fat::io; -use resize_fat::any; -use resize_fat::directory; - - -#- Oops, this will be unresizable on big-endian machine. trapped by signature. -my $format = "a3 a8 S C S C S S C S S S I I I S S I S S a458 S"; -my @fields = ( - 'boot_jump', #- boot strap short or near jump - 'system_id', #- Name - can be used to special case partition manager volumes - 'sector_size', #- bytes per logical sector - 'cluster_size_in_sectors', #- sectors/cluster - 'nb_reserved', #- reserved sectors - 'nb_fats', #- number of FATs - 'nb_root_dir_entries', #- number of root directory entries - 'small_nb_sectors', #- number of sectors: big_nb_sectors supersedes - 'media', #- media code - 'fat16_fat_length', #- sectors/FAT for FAT12/16 - 'sectors_per_track', - 'nb_heads', - 'nb_hidden', #- (unused) - 'big_nb_sectors', #- number of sectors (if small_nb_sectors == 0) - -#- FAT32-only entries - 'fat32_fat_length', #- size of FAT in sectors - 'fat32_flags', #- bit8: fat mirroring, - #- low4: active fat - 'fat32_version', #- minor * 256 + major - 'fat32_root_dir_cluster', - 'info_offset_in_sectors', - 'fat32_backup_sector', - -#- Common again... - 'boot_code', #- Boot code (or message) - 'boot_sign', #- 0xAA55 -); - -1; - - -#- trimfs_init_boot_sector() - reads in the boot sector - gets important info out -#- of boot sector, and puts in main structure - performs sanity checks - returns 1 -#- on success, 0 on failureparameters: filesystem an empty structure to fill. -sub read($) { - my ($fs) = @_; - - my $boot = eval { resize_fat::io::read($fs, 0, $SECTORSIZE) }; $@ and die "reading boot sector failed on device $fs->{fs_name}"; - @{$fs}{@fields} = unpack $format, $boot; - - $fs->{nb_sectors} = $fs->{small_nb_sectors} || $fs->{big_nb_sectors}; - $fs->{cluster_size} = $fs->{cluster_size_in_sectors} * $fs->{sector_size}; - - $fs->{boot_sign} == 0xAA55 or die "Invalid signature for a MS-based filesystem.\n"; - $fs->{nb_sectors} < 32 and die "Too few sectors for viable file system\n"; - $fs->{nb_fats} == 2 or cdie "Weird number of FATs: $fs->{nb_fats}, not 2.\n"; - $fs->{sector_size} == 512 or cdie "Strange sector_size != 512\n"; - - if ($fs->{fat16_fat_length}) { - #- asserting FAT16, will be verified later on - $resize_fat::isFAT32 = 0; - $fs->{fs_type} = 'FAT16'; - $fs->{fs_type_size} = 16; - $fs->{fat_length} = $fs->{fat16_fat_length}; - $resize_fat::bad_cluster_value = 0xfff7; #- 2**16 - 1 - } else { - $resize_fat::isFAT32 = 1; - $fs->{fs_type} = 'FAT32'; - $fs->{fs_type_size} = 32; - $fs->{fat_length} = $fs->{fat32_fat_length}; - - $fs->{nb_root_dir_entries} = 0; - $fs->{info_offset} = $fs->{info_offset_in_sectors} * $fs->{sector_size}; - $resize_fat::bad_cluster_value = 0x0ffffff7; - } - - $fs->{fat_offset} = $fs->{nb_reserved} * $fs->{sector_size}; - $fs->{fat_size} = $fs->{fat_length} * $fs->{sector_size}; - $fs->{root_dir_offset} = $fs->{fat_offset} + $fs->{fat_size} * $fs->{nb_fats}; - $fs->{root_dir_size} = $fs->{nb_root_dir_entries} * resize_fat::directory::entry_size(); - $fs->{cluster_offset} = $fs->{root_dir_offset} + $fs->{root_dir_size} - 2 * $fs->{cluster_size}; - - $fs->{nb_fat_entries} = divide($fs->{fat_size}, $fs->{fs_type_size} / 8); - - #- - 2 because clusters 0 & 1 doesn't exist - $fs->{nb_clusters} = divide($fs->{nb_sectors} * $fs->{sector_size} - $fs->{cluster_offset}, $fs->{cluster_size}) - 2; - - $fs->{dir_entries_per_cluster} = divide($fs->{cluster_size}, psizeof($format)); - -#- $fs->{nb_clusters} >= resize_fat::any::min_cluster_count($fs) or die "error: not enough sectors for a $fs->{fs_type}\n"; - $fs->{nb_clusters} < resize_fat::any::max_cluster_count($fs) or die "error: too many sectors for a $fs->{fs_type}\n"; -} - -sub write($) { - my ($fs) = @_; - my $boot = pack($format, @{$fs}{@fields}); - - eval { resize_fat::io::write($fs, 0, $SECTORSIZE, $boot) }; $@ and die "writing the boot sector failed on device $fs->{fs_name}"; - - if ($resize_fat::isFAT32) { - #- write backup - eval { resize_fat::io::write($fs, $fs->{fat32_backup_sector} * $SECTORSIZE, $SECTORSIZE, $boot) }; - $@ and die "writing the backup boot sector (#$fs->{fat32_backup_sector}) failed on device $fs->{fs_name}"; - } -} diff --git a/perl-install/resize_fat/c_rewritten.pm b/perl-install/resize_fat/c_rewritten.pm deleted file mode 100644 index d74ecb5d3..000000000 --- a/perl-install/resize_fat/c_rewritten.pm +++ /dev/null @@ -1,14 +0,0 @@ -package resize_fat::c_rewritten; # $Id$ - -use strict; -use vars qw($VERSION @ISA); - -require DynaLoader; - -@ISA = qw(DynaLoader); -$VERSION = '0.01'; - -bootstrap resize_fat::c_rewritten $VERSION; - -1; - diff --git a/perl-install/resize_fat/c_rewritten.xs b/perl-install/resize_fat/c_rewritten.xs deleted file mode 100644 index 92361097d..000000000 --- a/perl-install/resize_fat/c_rewritten.xs +++ /dev/null @@ -1,259 +0,0 @@ -#include "EXTERN.h" -#include "perl.h" -#include "XSUB.h" - -/* set by scan_fat, used by next */ -short *fat = NULL; -char *fat_flag_map = NULL; -unsigned int *fat_remap = NULL; -int fat_remap_size; -int type_size, nb_clusters, bad_cluster_value; - -void free_all() { -#define FREE(p) if (p) free(p), p = NULL; - FREE(fat); - FREE(fat_flag_map); - FREE(fat_remap); -#undef FREE -} - -unsigned int next(unsigned int cluster) { - short *p = fat + type_size * cluster; - if (!fat) { - free_all(); - croak("fat::next: trying to use null pointer"); - } - if (cluster >= nb_clusters + 2) { - free_all(); - croak("fat::next: cluster %d outside filesystem", cluster); - } - return type_size == 1 ? *p : *((unsigned int *) p); -} - -void set_next(unsigned int cluster, unsigned int val) { - short *p = fat + type_size * cluster; - if (!fat) { - free_all(); - croak("fat::set_next: trying to use null pointer"); - } - if (cluster >= nb_clusters + 2) { - free_all(); - croak("fat::set_next: cluster %d outside filesystem", cluster); - } - type_size == 1 ? *p : *((unsigned int *) p) = val; -} - -MODULE = resize_fat::c_rewritten PACKAGE = resize_fat::c_rewritten - -void -read_fat(fd, offset, size, magic) - int fd - int offset - int size - unsigned char magic - PPCODE: -{ - fat = (short *) malloc(size); - if (!fat) { - free_all(); - croak("read_fat: not enough memory"); - } - if (lseek(fd, offset, SEEK_SET) != offset || - read(fd, fat, size) != size) { - free_all(); - croak("read_fat: reading FAT failed"); - } - if (magic != *(unsigned char *) fat) { - free_all(); - croak("read_fat: FAT has invalid signature"); - } -} - -void -write_fat(fd, size) - int fd - int size - PPCODE: -{ - if (write(fd, fat, size) != size) { - free_all(); - croak("write_fat: write failed"); - } -} - -void -free_all() - PPCODE: - free_all(); - -void -scan_fat(nb_clusters_, type_size_) - int nb_clusters_ - int type_size_ - PPCODE: -{ - unsigned int v; - int free = 0, bad = 0, used = 0; - short *p; - - type_size = type_size_; nb_clusters = nb_clusters_; - bad_cluster_value = type_size == 32 ? 0x0ffffff7 : 0xfff7; - - if (type_size % 16) { - free_all(); - croak("scan_fat: unable to handle FAT%d", type_size); - } - type_size /= 16; - - for (p = fat + 2 * type_size; p < fat + type_size * (nb_clusters + 2); p += type_size) { - v = type_size == 1 ? *p : *((unsigned int *) p); - - if (v == 0) free++; - else if (v == bad_cluster_value) bad++; - } - used = nb_clusters - free - bad; - EXTEND(SP, 3); - PUSHs(sv_2mortal(newSViv(free))); - PUSHs(sv_2mortal(newSViv(bad))); - PUSHs(sv_2mortal(newSViv(used))); -} - -unsigned int -next(unused, cluster) - void *unused - unsigned int cluster - CODE: - RETVAL = next(cluster); - OUTPUT: - RETVAL - -void -set_next(unused, cluster, val) - void *unused - unsigned int cluster - unsigned int val - CODE: - set_next(cluster, val); - -void -allocate_fat_flag(size) - int size - CODE: - fat_flag_map = calloc(size, 1); - if (!fat_flag_map) { - free_all(); - croak("allocate_fat_flag: not enough memory"); - } - -int -checkFat(cluster, type, name) - unsigned int cluster - int type - char *name - CODE: - int nb = 0; - - if (!fat_flag_map) { - free_all(); - croak("Bad FAT: trying to use null pointer"); - } - for (; cluster < bad_cluster_value; cluster = next(cluster)) { - if (cluster == 0) { - free_all(); - croak("Bad FAT: unterminated chain for %s\n", name); - } - if (cluster >= nb_clusters + 2) { - free_all(); - croak("Bad FAT: chain outside filesystem for %s\n", name); - } - if (fat_flag_map[cluster]) { - free_all(); - croak("Bad FAT: cluster %d is cross-linked for %s\n", cluster, name); - } - fat_flag_map[cluster] = type; - nb++; - } - RETVAL = nb; - OUTPUT: - RETVAL - -unsigned int -flag(cluster) - unsigned int cluster - CODE: - if (!fat_flag_map) { - free_all(); - croak("Bad FAT: trying to use null pointer"); - } - if (cluster >= nb_clusters + 2) { - free_all(); - croak("Bad FAT: going outside filesystem"); - } - RETVAL = fat_flag_map[cluster]; - OUTPUT: - RETVAL - -void -set_flag(cluster, flag) - unsigned int cluster - int flag - CODE: - if (!fat_flag_map) { - free_all(); - croak("Bad FAT: trying to use null pointer"); - } - if (cluster >= nb_clusters + 2) { - free_all(); - croak("Bad FAT: going outside filesystem"); - } - fat_flag_map[cluster] = flag; - -void -allocate_fat_remap(size) - int size - CODE: - fat_remap_size = size; - fat_remap = (unsigned int *) calloc(size, sizeof(unsigned int *)); - if (!fat_remap) { - free_all(); - croak("allocate_fat_remap: not enough memory"); - } - -unsigned int -fat_remap(cluster) - unsigned int cluster - CODE: - if (!fat_remap) { - free_all(); - croak("fat_remap: trying to use null pointer"); - } - if (cluster >= bad_cluster_value) { - RETVAL = cluster; /* special cases */ - } else { - if (cluster >= fat_remap_size) { - free_all(); - croak("fat_remap: cluster %d >= %d in fat_remap", cluster, fat_remap_size); - } - RETVAL = fat_remap[cluster]; - } - OUTPUT: - RETVAL - -void -set_fat_remap(cluster, val) - unsigned int cluster - unsigned int val - CODE: - if (!fat_remap) { - free_all(); - croak("set_fat_remap: trying to use null pointer"); - } - if (cluster >= fat_remap_size) { - free_all(); - croak("set_fat_remap: cluster %d >= %d in set_fat_remap", cluster, fat_remap_size); - } - if (val < bad_cluster_value && val >= fat_remap_size) { - free_all(); - croak("set_fat_remap: remapping cluster %d to cluster %d >= %d in set_fat_remap", cluster, val, fat_remap_size); - } - fat_remap[cluster] = val; diff --git a/perl-install/resize_fat/dir_entry.pm b/perl-install/resize_fat/dir_entry.pm deleted file mode 100644 index b39c72094..000000000 --- a/perl-install/resize_fat/dir_entry.pm +++ /dev/null @@ -1,77 +0,0 @@ -package resize_fat::dir_entry; # $Id$ - -use diagnostics; -use strict; - - -my $DELETED_FLAG = 0xe5; - -my $READ_ONLY_ATTR = 0x01; -my $HIDDEN_ATTR = 0x02; -my $SYSTEM_ATTR = 0x04; -my $VOLUME_LABEL_ATTR = 0x08; -my $VFAT_ATTR = 0x0f; -my $DIRECTORY_ATTR = 0x10; - -1; - -sub get_cluster($) { - my ($entry) = @_; - $entry->{first_cluster} + ($resize_fat::isFAT32 ? $entry->{first_cluster_high} * (1 << 16) : 0); -} -sub set_cluster($$) { - my ($entry, $val) = @_; - $entry->{first_cluster} = $val & (1 << 16) - 1; - $entry->{first_cluster_high} = $val >> 16 if $resize_fat::isFAT32; -} - -sub is_unmoveable($) { - my ($entry) = @_; - $entry->{attributes} & $HIDDEN_ATTR || $entry->{attributes} & $SYSTEM_ATTR; -} - -sub is_directory($) { - my ($entry) = @_; - $entry->{attributes} & $DIRECTORY_ATTR && $entry->{name} !~ /^\.\.? / && !is_special_entry($entry); -} - -sub is_volume($) { - my ($entry) = @_; - !is_special_entry($entry) && $entry->{attributes} & $VOLUME_LABEL_ATTR; -} - -sub is_file($) { - my ($entry) = @_; - !is_special_entry($entry) && !is_directory($entry) && !is_volume($entry) && $entry->{length}; -} - - -sub is_special_entry($) { - my ($entry) = @_; - my ($c) = unpack "C", $entry->{name}; - - #- skip empty slots, deleted files, and 0xF6?? (taken from kernel) - $c == 0 || $c == $DELETED_FLAG || $c == 0xF6 and return 1; - - $entry->{attributes} == $VFAT_ATTR and return 1; - 0; -} - - -#- return true if entry has been modified -#- curr_dir_name is added to contains current directory name, "" for root. -sub remap { - my ($curr_dir_name, $entry) = @_; - - is_special_entry($entry) and return; - - my $cluster = get_cluster($entry); - my $new_cluster = resize_fat::c_rewritten::fat_remap($cluster); - - #-print "remapping cluster ", get_cluster($entry), " to $new_cluster"; - - $new_cluster == $cluster and return; #- no need to modify - - set_cluster($entry, $new_cluster); - 1; -} diff --git a/perl-install/resize_fat/directory.pm b/perl-install/resize_fat/directory.pm deleted file mode 100644 index 1f2b1ede6..000000000 --- a/perl-install/resize_fat/directory.pm +++ /dev/null @@ -1,79 +0,0 @@ -package resize_fat::directory; # $Id$ - -use diagnostics; -use strict; - -use common; -use resize_fat::dir_entry; -use resize_fat::io; - - -my $format = "a8 a3 C C C S7 I"; -my @fields = ( - 'name', - 'extension', - 'attributes', - 'is_upper_case_name', - 'creation_time_low', #- milliseconds - 'creation_time_high', - 'creation_date', - 'access_date', - 'first_cluster_high', #- for FAT32 - 'time', - 'date', - 'first_cluster', - 'length', -); -my $psizeof_format = psizeof($format); - -1; - -sub entry_size { $psizeof_format } - -#- call `f' for each entry of the directory -#- if f return true, then modification in the entry are taken back -sub traverse($$$) { - my ($directory, $curr_dir_name, $f) = @_; - - for (my $i = 0;; $i++) { - my $raw = \substr($directory, $i * $psizeof_format, $psizeof_format); - - #- empty entry means end of directory - $$raw =~ /^\0*$/ and return $directory; - - my $entry; @{$entry}{@fields} = unpack $format, $$raw; - - &$f($curr_dir_name, $entry) - and $$raw = pack $format, @{$entry}{@fields}; - } - $directory; -} - -sub traverse_all($$) { - my ($fs, $f) = @_; - - my $traverse_all; $traverse_all = sub { - my ($curr_dir_name, $entry) = @_; - - &$f($curr_dir_name, $entry); - - resize_fat::dir_entry::is_directory($entry) - and traverse(resize_fat::io::read_file($fs, resize_fat::dir_entry::get_cluster($entry)), "$curr_dir_name/$entry->{name}", $traverse_all); - - undef; #- no need to write back (cf traverse) - }; - - my $directory = $resize_fat::isFAT32 ? - resize_fat::io::read_file($fs, $fs->{fat32_root_dir_cluster}) : - resize_fat::io::read($fs, $fs->{root_dir_offset}, $fs->{root_dir_size}); - traverse($directory, "", $traverse_all); - undef $traverse_all; #- circular reference is no good for perl's poor GC :( -} - - -#- function used by construct_dir_tree to translate the `cluster' fields in each -#- directory entry -sub remap($$) { - my ($fs, $directory) = @_; - traverse($directory, "", \&resize_fat::dir_entry::remap); -} diff --git a/perl-install/resize_fat/fat.pm b/perl-install/resize_fat/fat.pm deleted file mode 100644 index 31643f0a3..000000000 --- a/perl-install/resize_fat/fat.pm +++ /dev/null @@ -1,138 +0,0 @@ -package resize_fat::fat; # $Id$ - -use diagnostics; -use strict; - -use resize_fat::any; -use resize_fat::io; -use resize_fat::c_rewritten; - -1; - -sub read($) { - my ($fs) = @_; - - resize_fat::c_rewritten::read_fat(fileno $fs->{fd}, $fs->{fat_offset}, $fs->{fat_size}, $fs->{media}); - - @{$fs->{clusters}{count}}{qw(free bad used)} = - resize_fat::c_rewritten::scan_fat($fs->{nb_clusters}, $fs->{fs_type_size}); -} - -sub write($) { - my ($fs) = @_; - - sysseek $fs->{fd}, $fs->{fat_offset}, 0 or die "write_fat: seek failed"; - foreach (1..$fs->{nb_fats}) { - resize_fat::c_rewritten::write_fat(fileno $fs->{fd}, $fs->{fat_size}); - } -} - - - -#- allocates where all the clusters will be moved to. Clusters before cut_point -#- remain in the same position, however cluster that are part of a directory are -#- moved regardless (this is a mechanism to prevent data loss) (cut_point is the -#- first cluster that won't occur in the new fs) -sub allocate_remap { - my ($fs, $cut_point) = @_; - my ($cluster, $new_cluster); - my $remap = sub { resize_fat::c_rewritten::set_fat_remap($cluster, $new_cluster) }; - my $get_new = sub { - $new_cluster = get_free($fs); - 0 < $new_cluster && $new_cluster < $cut_point or die "no free clusters"; - set_eof($fs, $new_cluster); #- mark as used - #-log::ld("resize_fat: [$cluster,", &next($fs, $cluster), "...]->$new_cluster..."); - }; - - #- this must call allocate_fat_remap that zeroes the buffer allocated. - resize_fat::c_rewritten::allocate_fat_remap($fs->{nb_clusters} + 2); - - $fs->{last_free_cluster} = 2; - for ($cluster = 2; $cluster < $fs->{nb_clusters} + 2; $cluster++) { - if ($cluster < $cut_point) { - if (resize_fat::c_rewritten::flag($cluster) == $resize_fat::any::DIRECTORY) { - &$get_new(); - } else { - $new_cluster = $cluster; - } - &$remap(); - } elsif (!is_empty(&next($fs, $cluster))) { - &$get_new(); - &$remap(); - } - } -} - - -#- updates the fat for the resized filesystem -sub update { - my ($fs) = @_; - - for (my $cluster = 2; $cluster < $fs->{nb_clusters} + 2; $cluster++) { - if (resize_fat::c_rewritten::flag($cluster)) { - my $old_next = &next($fs, $cluster); - my $new = resize_fat::c_rewritten::fat_remap($cluster); - my $new_next = resize_fat::c_rewritten::fat_remap($old_next); - - set_available($fs, $cluster); - - is_eof($old_next) ? - set_eof($fs, $new) : - set_next ($fs, $new, $new_next); - } - } -} - - -sub endianness16($) { (($_[0] & 0xff) << 8) + ($_[0] >> 8); } -sub endianness($$) { - my ($val, $nb_bits) = @_; - my $r = 0; - for (; $nb_bits > 0; $nb_bits -= 8) { - $r <<= 8; - $r += $val & 0xff; - $val >>= 8; - } - $nb_bits < 0 and die "error: endianness only handle numbers divisible by 8"; - $r; -} - -*next = \&resize_fat::c_rewritten::next; -*set_next = \&resize_fat::c_rewritten::set_next; - - - -sub get_free($) { - my ($fs) = @_; - foreach (my $i = 0; $i < $fs->{nb_clusters}; $i++) { - my $cluster = ($i + $fs->{last_free_cluster} - 2) % $fs->{nb_clusters} + 2; - is_available(&next($fs, $cluster)) and return $fs->{last_free_cluster} = $cluster; - } - die "no free clusters"; -} - -#- returns true if <cluster> represents an EOF marker -sub is_eof($) { - my ($cluster) = @_; - $cluster >= $resize_fat::bad_cluster_value; -} -sub set_eof($$) { - my ($fs, $cluster) = @_; - set_next ($fs, $cluster, $resize_fat::bad_cluster_value + 1); -} - -#- returns true if <cluster> is empty. Note that this includes bad clusters. -sub is_empty($) { - my ($cluster) = @_; - $cluster == 0 || $cluster == $resize_fat::bad_cluster_value; -} - -#- returns true if <cluster> is available. -sub is_available($) { - my ($cluster) = @_; - $cluster == 0; -} -sub set_available($$) { - my ($fs, $cluster) = @_; - set_next ($fs, $cluster, 0); -} diff --git a/perl-install/resize_fat/info_sector.pm b/perl-install/resize_fat/info_sector.pm deleted file mode 100644 index 35449cedc..000000000 --- a/perl-install/resize_fat/info_sector.pm +++ /dev/null @@ -1,37 +0,0 @@ -package resize_fat::info_sector; # $Id$ - -use diagnostics; -use strict; - -use common; -use resize_fat::io; - -#- Oops, this will be unresizable on big-endian machine. trapped by signature. -my $format = "a484 I I I a16"; -my @fields = ( - 'unused', - 'signature', #- should be 0x61417272 - 'free_clusters', #- -1 for unknown - 'next_cluster', #- most recently allocated cluster - 'unused2', -); - -1; - - -sub read($) { - my ($fs) = @_; - my $info = resize_fat::io::read($fs, $fs->{info_offset}, psizeof($format)); - @{$fs->{info_sector}}{@fields} = unpack $format, $info; - $fs->{info_sector}{signature} == 0x61417272 or die "Invalid information sector signature\n"; -} - -sub write($) { - my ($fs) = @_; - $fs->{info_sector}{free_clusters} = $fs->{clusters}->{count}->{free}; - $fs->{info_sector}{next_cluster} = 2; - - my $info = pack $format, @{$fs->{info_sector}}{@fields}; - - resize_fat::io::write($fs, $fs->{info_offset}, psizeof($format), $info); -} diff --git a/perl-install/resize_fat/io.pm b/perl-install/resize_fat/io.pm deleted file mode 100644 index 7643a0953..000000000 --- a/perl-install/resize_fat/io.pm +++ /dev/null @@ -1,71 +0,0 @@ -package resize_fat::io; # $Id$ - -use diagnostics; -use strict; - -use resize_fat::fat; -use c; - -1; - - -sub read($$$) { - my ($fs, $pos, $size) = @_; - print "reading $size bytes at $pos\n"; - my $buf = "\0" x $size; - sysseek $fs->{fd}, $pos, 0 or die "seeking to byte #$pos failed on device $fs->{fs_name}"; - sysread $fs->{fd}, $buf, $size or die "reading at byte #$pos failed on device $fs->{fs_name}"; - $buf; -} -sub write($$$$) { - my ($fs, $pos, $size, $buf) = @_; - sysseek $fs->{fd}, $pos, 0 or die "seeking to byte #$pos failed on device $fs->{fs_name}"; - syswrite $fs->{fd}, $buf or die "writing at byte #$pos failed on device $fs->{fs_name}"; -} - -sub read_cluster($$) { - my ($fs, $cluster) = @_; - my $buf; - my $pos = $fs->{cluster_offset} / 512 + $cluster * ($fs->{cluster_size} / 512); - - c::lseek_sector(fileno $fs->{fd}, $pos, 0) or die "seeking to sector #$pos failed on device $fs->{fs_name}"; - sysread $fs->{fd}, $buf, $fs->{cluster_size} or die "reading at sector #$pos failed on device $fs->{fs_name}"; - $buf; -} -sub write_cluster($$$) { - my ($fs, $cluster, $buf) = @_; - my $pos = $fs->{cluster_offset} / 512 + $cluster * ($fs->{cluster_size} / 512); - - c::lseek_sector(fileno $fs->{fd}, $pos, 0) or die "seeking to sector #$pos failed on device $fs->{fs_name}"; - syswrite $fs->{fd}, $buf or die "writing at sector #$pos failed on device $fs->{fs_name}"; -} - -sub read_file($$) { - my ($fs, $cluster) = @_; - my $buf = ''; - - for (; !resize_fat::fat::is_eof($cluster); $cluster = resize_fat::fat::next ($fs, $cluster)) { - $cluster == 0 and die "Bad FAT: unterminated chain\n"; - $buf .= read_cluster($fs, $cluster); - } - $buf; -} - -sub check_mounted($) { - my ($f) = @_; - - local *F; - open F, "/proc/mounts" or die "error opening /proc/mounts\n"; - foreach (<F>) { - /^$f\s/ and die "device is mounted"; - } -} - -sub open($) { - my ($fs) = @_; - - check_mounted($fs->{device}); - - sysopen F, $fs->{fs_name}, 2 or sysopen F, $fs->{fs_name}, 0 or die "error opening device $fs->{fs_name} for writing\n"; - $fs->{fd} = *F; -} diff --git a/perl-install/resize_fat/main.pm b/perl-install/resize_fat/main.pm deleted file mode 100644 index 81dfb6b3f..000000000 --- a/perl-install/resize_fat/main.pm +++ /dev/null @@ -1,186 +0,0 @@ -#!/usr/bin/perl - -# DiskDrake -# Copyright (C) 1999 MandrakeSoft (pixel@mandrakesoft.com) -# -# This program is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation; either version 2, or (at your option) -# any later version. -# -# This program is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with this program; if not, write to the Free Software -# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -# This is mainly a perl rewrite of the work of Andrew Clausen (libresize) - -package resize_fat::main; # $Id$ - -use diagnostics; -use strict; - -use log; -use common; -use MDK::Common::System; -use resize_fat::boot_sector; -use resize_fat::info_sector; -use resize_fat::directory; -use resize_fat::io; -use resize_fat::fat; -use resize_fat::any; - - -1; - -#- - reads in the boot sector/partition info., and tries to make some sense of it -sub new($$$) { - my ($type, $device, $fs_name) = @_; - my $fs = { device => $device, fs_name => $fs_name } ; - - eval { - resize_fat::io::open($fs); - resize_fat::boot_sector::read($fs); - $resize_fat::isFAT32 and eval { resize_fat::info_sector::read($fs) }; - resize_fat::fat::read($fs); - resize_fat::any::flag_clusters($fs); - }; - if ($@) { - close $fs->{fd}; - die; - } - bless $fs, $type; -} - -sub DESTROY { - my ($fs) = @_; - close $fs->{fd}; - resize_fat::c_rewritten::free_all(); -} - -#- copy all clusters >= <start_cluster> to a new place on the partition, less -#- than <start_cluster>. Only copies files, not directories. -#- (use of buffer needed because the seeks slow like hell the hard drive) -sub copy_clusters { - my ($fs, $cluster) = @_; - my @buffer; - my $flush = sub { - while (@buffer) { - my $cluster = shift @buffer; - resize_fat::io::write_cluster($fs, $cluster, shift @buffer); - } - }; - for (; $cluster < $fs->{nb_clusters} + 2; $cluster++) { - resize_fat::c_rewritten::flag($cluster) == $resize_fat::any::FILE or next; - push @buffer, - resize_fat::c_rewritten::fat_remap($cluster), - resize_fat::io::read_cluster($fs, $cluster); - @buffer > 50 and &$flush(); - } - &$flush(); -} - -#- Constructs the new directory tree to match the new file locations. -sub construct_dir_tree { - my ($fs) = @_; - - if ($resize_fat::isFAT32) { - #- fat32's root must remain in the first 64k clusters - #- so don't set it as DIRECTORY, it will be specially handled - resize_fat::c_rewritten::set_flag($fs->{fat32_root_dir_cluster}, $resize_fat::any::FREE); - } - - for (my $cluster = 2; $cluster < $fs->{nb_clusters} + 2; $cluster++) { - resize_fat::c_rewritten::flag($cluster) == $resize_fat::any::DIRECTORY or next; - - resize_fat::io::write_cluster($fs, - resize_fat::c_rewritten::fat_remap($cluster), - resize_fat::directory::remap($fs, resize_fat::io::read_cluster($fs, $cluster))); - } - - MDK::Common::System::sync(); - - #- until now, only free clusters have been written. it's a null operation if we stop here. - #- it means no corruption :) - # - #- now we must be as fast as possible! - - #- remapping non movable root directory - if ($resize_fat::isFAT32) { - my $cluster = $fs->{fat32_root_dir_cluster}; - - resize_fat::io::write_cluster($fs, - resize_fat::c_rewritten::fat_remap($cluster), - resize_fat::directory::remap($fs, resize_fat::io::read_cluster($fs, $cluster))); - } else { - resize_fat::io::write($fs, $fs->{root_dir_offset}, $fs->{root_dir_size}, - resize_fat::directory::remap($fs, resize_fat::io::read($fs, $fs->{root_dir_offset}, $fs->{root_dir_size}))); - } -} - -sub min_size($) { &resize_fat::any::min_size } -sub max_size($) { &resize_fat::any::max_size } -sub used_size($) { &resize_fat::any::used_size } - -#- resize -#- - size is in sectors -#- - checks boundaries before starting -#- - copies all data beyond new_cluster_count behind the frontier -sub resize { - my ($fs, $size) = @_; - - my ($min, $max) = (min_size($fs), max_size($fs)); - - $size += $min if $size =~ /^\+/; - - $size >= $min or die "Minimum filesystem size is $min sectors"; - $size <= $max or die "Maximum filesystem size is $max sectors"; - - log::l("resize_fat: Partition size will be ". ($size * $SECTORSIZE >> 20) ."Mb (well exactly ${size} sectors)"); - - my $new_data_size = $size * $SECTORSIZE - $fs->{cluster_offset}; - my $new_nb_clusters = divide($new_data_size, $fs->{cluster_size}); - my $used_size = used_size($fs); - - log::l("resize_fat: Break point for moving files is ". ($used_size * $SECTORSIZE >> 20) ." Mb ($used_size sectors)"); - if ($size < $used_size) { - log::l("resize_fat: Allocating new clusters"); - resize_fat::fat::allocate_remap($fs, $new_nb_clusters); - - log::l("resize_fat: Copying files"); - copy_clusters($fs, $new_nb_clusters); - - log::l("resize_fat: Copying directories"); - construct_dir_tree($fs); - - log::l("Writing new FAT..."); - resize_fat::fat::update($fs); - resize_fat::fat::write($fs); - } else { - log::l("resize_fat: Nothing need to be moved"); - } - - $fs->{nb_sectors} = $size; - $fs->{nb_clusters} = $new_nb_clusters; - $fs->{clusters}{count}->{free} = - $fs->{nb_clusters} - $fs->{clusters}{count}->{used} - $fs->{clusters}->{count}->{bad} - 2; - - $fs->{system_id} = 'was here!'; - $fs->{small_nb_sectors} = 0; - $fs->{big_nb_sectors} = $size; - - log::l("resize_fat: Writing new boot sector..."); - - resize_fat::boot_sector::write($fs); - - $resize_fat::isFAT32 and eval { resize_fat::info_sector::write($fs) }; #- doesn't matter if this fails - its pretty useless! - - MDK::Common::System::sync(); - close $fs->{fd}; - log::l("resize_fat: done"); -} - |