Changes in / [b0d309f:a2271a3] in mainline


Ignore:
Files:
2 deleted
6 edited

Legend:

Unmodified
Added
Removed
  • HelenOS.config

    rb0d309f ra2271a3  
    8888@ "tmpfs" TMPFS image
    8989@ "fat" FAT16 image
    90 @ "ext2fs" EXT2 image
    9190! RDFMT (choice)
    9291
  • boot/Makefile

    rb0d309f ra2271a3  
    5050        $(MKFAT) 1048576 $(DIST_PATH) $@
    5151endif
    52 ifeq ($(RDFMT),ext2fs)
    53         $(MKEXT2) 1048576 $(DIST_PATH) $@
    54 endif
    5552
    5653build_dist: clean_dist
  • boot/Makefile.common

    rb0d309f ra2271a3  
    5656MKTMPFS = $(TOOLS_PATH)/mktmpfs.py
    5757MKFAT = $(TOOLS_PATH)/mkfat.py
    58 MKEXT2 = $(TOOLS_PATH)/mkext2.py
    5958MKUIMAGE = $(TOOLS_PATH)/mkuimage.py
    6059
     
    8382ifeq ($(RDFMT),fat)
    8483        INIT_TASKS += $(USPACE_PATH)/srv/fs/fat/fat
    85 endif
    86 
    87 ifeq ($(RDFMT),ext2fs)
    88         INIT_TASKS += $(USPACE_PATH)/srv/fs/ext2fs/ext2fs
    8984endif
    9085
  • tools/mkfat.py

    rb0d309f ra2271a3  
    3737import xstruct
    3838import array
    39 from imgutil import *
     39
     40exclude_names = set(['.svn', '.bzr'])
     41
     42def align_up(size, alignment):
     43        "Return size aligned up to alignment"
     44       
     45        if (size % alignment == 0):
     46                return size
     47       
     48        return ((size // alignment) + 1) * alignment
    4049
    4150def subtree_size(root, cluster_size, dirent_size):
     
    4554        files = 2
    4655       
    47         for item in listdir_items(root):
    48                 if item.is_file:
    49                         size += align_up(item.size, cluster_size)
     56        for name in os.listdir(root):
     57                canon = os.path.join(root, name)
     58               
     59                if (os.path.isfile(canon) and (not name in exclude_names)):
     60                        size += align_up(os.path.getsize(canon), cluster_size)
    5061                        files += 1
    51                 elif item.is_dir:
    52                         size += subtree_size(item.path, cluster_size, dirent_size)
     62               
     63                if (os.path.isdir(canon) and (not name in exclude_names)):
     64                        size += subtree_size(canon, cluster_size, dirent_size)
    5365                        files += 1
    5466       
     
    6072        return len(os.listdir(root))
    6173
    62 def write_file(item, outf, cluster_size, data_start, fat, reserved_clusters):
     74def write_file(path, outf, cluster_size, data_start, fat, reserved_clusters):
    6375        "Store the contents of a file"
    6476       
     77        size = os.path.getsize(path)
    6578        prev = -1
    6679        first = 0
    6780       
    68         for data in chunks(item, cluster_size):
     81        inf = open(path, "rb")
     82        rd = 0;
     83        while (rd < size):
    6984                empty_cluster = fat.index(0)
    7085                fat[empty_cluster] = 0xffff
     
    7792                prev = empty_cluster
    7893               
     94                data = bytes(inf.read(cluster_size));
    7995                outf.seek(data_start + (empty_cluster - reserved_clusters) * cluster_size)
    8096                outf.write(data)
    81        
    82         return first, item.size
     97                rd += len(data)
     98        inf.close()
     99       
     100        return first, size
    83101
    84102def write_directory(directory, outf, cluster_size, data_start, fat, reserved_clusters, dirent_size, empty_cluster):
     
    285303                empty_cluster = 0
    286304       
    287         for item in listdir_items(root):               
    288                 if item.is_file:
    289                         rv = write_file(item, outf, cluster_size, data_start, fat, reserved_clusters)
    290                         directory.append(create_dirent(item.name, False, rv[0], rv[1]))
    291                 elif item.is_dir:
    292                         rv = recursion(False, item.path, outf, cluster_size, root_start, data_start, fat, reserved_clusters, dirent_size, empty_cluster)
    293                         directory.append(create_dirent(item.name, True, rv[0], rv[1]))
     305        for name in os.listdir(root):
     306                canon = os.path.join(root, name)
     307               
     308                if (os.path.isfile(canon) and (not name in exclude_names)):
     309                        rv = write_file(canon, outf, cluster_size, data_start, fat, reserved_clusters)
     310                        directory.append(create_dirent(name, False, rv[0], rv[1]))
     311               
     312                if (os.path.isdir(canon) and (not name in exclude_names)):
     313                        rv = recursion(False, canon, outf, cluster_size, root_start, data_start, fat, reserved_clusters, dirent_size, empty_cluster)
     314                        directory.append(create_dirent(name, True, rv[0], rv[1]))
    294315       
    295316        if (head):
  • tools/mktmpfs.py

    rb0d309f ra2271a3  
    3535import os
    3636import xstruct
    37 from imgutil import listdir_items, chunks
     37
     38exclude_names = set(['.svn', '.bzr'])
    3839
    3940HEADER = """little:
     
    7071        "Recursive directory walk"
    7172       
    72         for item in listdir_items(root):               
    73                 if item.is_file:                       
    74                         dentry = xstruct.create(DENTRY_FILE % len(item.name))
     73        for name in os.listdir(root):
     74                canon = os.path.join(root, name)
     75               
     76                if (os.path.isfile(canon) and (not name in exclude_names)):
     77                        size = os.path.getsize(canon)
     78                       
     79                        dentry = xstruct.create(DENTRY_FILE % len(name))
    7580                        dentry.kind = TMPFS_FILE
    76                         dentry.fname_len = len(item.name)
    77                         dentry.fname = item.name.encode('ascii')
    78                         dentry.flen = item.size
     81                        dentry.fname_len = len(name)
     82                        dentry.fname = name.encode('ascii')
     83                        dentry.flen = size
    7984                       
    8085                        outf.write(dentry.pack())
    8186                       
    82                         for data in chunks(item, 4096):
     87                        inf = open(canon, "rb")
     88                        rd = 0;
     89                        while (rd < size):
     90                                data = inf.read(4096);
    8391                                outf.write(data)
     92                                rd += len(data)
     93                        inf.close()
    8494               
    85                 elif item.is_dir:
    86                         dentry = xstruct.create(DENTRY_DIRECTORY % len(item.name))
     95                if (os.path.isdir(canon) and (not name in exclude_names)):
     96                        dentry = xstruct.create(DENTRY_DIRECTORY % len(name))
    8797                        dentry.kind = TMPFS_DIRECTORY
    88                         dentry.fname_len = len(item.name)
    89                         dentry.fname = item.name.encode('ascii')
     98                        dentry.fname_len = len(name)
     99                        dentry.fname = name.encode('ascii')
    90100                       
    91101                        outf.write(dentry.pack())
    92102                       
    93                         recursion(item.path, outf)
     103                        recursion(canon, outf)
    94104                       
    95105                        dentry = xstruct.create(DENTRY_NONE)
  • tools/xstruct.py

    rb0d309f ra2271a3  
    11#
    22# Copyright (c) 2008 Martin Decky
    3 # Copyright (c) 2011 Martin Sucha
    43# All rights reserved.
    54#
     
    3231
    3332import struct
    34 import types
    35 
    36 ranges = {
    37         'B': ((int, long), 0x00, 0xff),
    38         'H': ((int, long), 0x0000, 0xffff),
    39         'L': ((int, long), 0x00000000, 0xffffffff),
    40         'Q': ((int, long), 0x0000000000000000, 0xffffffffffffffff),
    41         'b': ((int, long), -0x80, 0x7f),
    42         'h': ((int, long), -0x8000, 0x7fff),
    43         'l': ((int, long), -0x80000000, 0x7fffffff) ,
    44         'q': ((int, long), -0x8000000000000000, 0x7fffffffffffffff),
    45 }
    46 
    47 def check_range(varname, fmt, value):
    48         if value == None:
    49                 raise ValueError('Variable "%s" not set' % varname)
    50         if not fmt in ranges:
    51                 return
    52         vartype, varmin, varmax = ranges[fmt]
    53         if not isinstance(value, vartype):
    54                 raise ValueError('Variable "%s" is %s but should be %s' %
    55                                  (varname, str(type(value)), str(vartype)))
    56         if value < varmin or value > varmax:
    57                 raise ValueError('Variable "%s" value %s out of range %s..%s' %
    58                                  (varname, repr(value), repr(varmin), repr(varmax)))
    5933
    6034class Struct:
     
    6438        def pack(self):
    6539                args = []
    66                 for variable, fmt, length in self._args_:
    67                         value = self.__dict__[variable]
    68                         if isinstance(value, list):
    69                                 if length != None and length != len(value):
    70                                         raise ValueError('Variable "%s" length %u does not match %u' %
    71                                                       (variable, len(value), length))
    72                                 for index, item in enumerate(value):
    73                                         check_range(variable + '[' + repr(index) + ']', fmt, item)
     40                for variable in self._args_:
     41                        if (isinstance(self.__dict__[variable], list)):
     42                                for item in self.__dict__[variable]:
    7443                                        args.append(item)
    7544                        else:
    76                                 check_range(variable, fmt, value)
    77                                 args.append(value)             
     45                                args.append(self.__dict__[variable])
     46               
    7847                return struct.pack(self._format_, *args)
    79        
    80         def unpack(self, data):
    81                 values = struct.unpack(self._format_, data)
    82                 i = 0
    83                 for variable, fmt, length in self._args_:
    84                         self.__dict__[variable] = values[i]
    85                         i += 1
    8648
    8749def create(definition):
     
    11577                        subtokens = token.split("[")
    11678                       
    117                         length = None
    11879                        if (len(subtokens) > 1):
    119                                 length = int(subtokens[1].split("]")[0])
    120                                 format += "%d" % length
     80                                format += "%d" % int(subtokens[1].split("]")[0])
    12181                       
    12282                        format += variable
    12383                       
    12484                        inst.__dict__[subtokens[0]] = None
    125                         args.append((subtokens[0], variable, length))
     85                        args.append(subtokens[0])
    12686                       
    12787                        variable = None
Note: See TracChangeset for help on using the changeset viewer.