Changeset a35b458 in mainline for tools/mkext2.py


Ignore:
Timestamp:
2018-03-02T20:10:49Z (7 years ago)
Author:
Jiří Zárevúcky <zarevucky.jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
f1380b7
Parents:
3061bc1
git-author:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-02-28 17:38:31)
git-committer:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-03-02 20:10:49)
Message:

style: Remove trailing whitespace on _all_ lines, including empty ones, for particular file types.

Command used: tools/srepl '\s\+$' '' -- *.c *.h *.py *.sh *.s *.S *.ag

Currently, whitespace on empty lines is very inconsistent.
There are two basic choices: Either remove the whitespace, or keep empty lines
indented to the level of surrounding code. The former is AFAICT more common,
and also much easier to do automatically.

Alternatively, we could write script for automatic indentation, and use that
instead. However, if such a script exists, it's possible to use the indented
style locally, by having the editor apply relevant conversions on load/save,
without affecting remote repository. IMO, it makes more sense to adopt
the simpler rule.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • tools/mkext2.py

    r3061bc1 ra35b458  
    7777        uint32_t rev_major            /* Major revision level */
    7878        padding[4] /* default reserved uid and gid */
    79        
     79
    8080        /* Following is for ext2 revision 1 only */
    8181        uint32_t first_inode
    … …  
    130130        def __init__(self, filename, block_groups, blocks_per_group, inodes_per_group, block_size, inode_size, reserved_inode_count):
    131131                "Initialize the filesystem writer"
    132                
     132
    133133                outf = open(filename, "w+b")
    134134                # Set the correct size of the image, so that we can read arbitrary position
    … …  
    172172                lpf_dir.add(self.root_inode.as_dirent('..'))
    173173                lpf_dir.finish()
    174        
     174
    175175        def init_gdt(self):
    176176                "Initialize block group descriptor table"
    177                
     177
    178178                self.superblock_positions = []
    179179                self.gdt = []
    … …  
    202202                        gde.directory_inode_count = 0
    203203                        self.gdt.append(gde)
    204        
     204
    205205        def mark_block_cb(self, block):
    206206                "Called after a block has been allocated"
    207                
     207
    208208                self.gdt[block // self.blocks_per_group].free_block_count -= 1
    209        
     209
    210210        def mark_inode_cb(self, index, directory=False):
    211211                "Called after an inode has been allocated"
    212                
     212
    213213                index -= 1
    214214                gde = self.gdt[index // self.inodes_per_group]
    … …  
    216216                if directory:
    217217                        gde.directory_inode_count += 1
    218        
     218
    219219        def seek_to_block(self, block, offset=0):
    220220                "Seek to offset bytes after the start of the given block"
    221                
     221
    222222                if offset < 0 or offset > self.block_size:
    223223                        raise Exception("Invalid in-block offset")
    224224                self.outf.seek(block * self.block_size + offset)
    225        
     225
    226226        def seek_to_inode(self, index):
    227227                "Seek to the start of the inode structure for the inode number index"
    228                
     228
    229229                index -= 1
    230230                if index < 0:
    … …  
    235235                block = base_block + (offset // self.block_size)
    236236                self.seek_to_block(block, offset % self.block_size)
    237        
     237
    238238        def subtree_add(self, inode, parent_inode, dirpath, is_root=False):
    239239                "Recursively add files to the filesystem"
    240                
     240
    241241                dir_writer = DirWriter(inode)
    242242                dir_writer.add(inode.as_dirent('.'))
    243243                dir_writer.add(parent_inode.as_dirent('..'))
    244                
     244
    245245                if is_root:
    246246                        dir_writer.add(self.lost_plus_found.as_dirent('lost+found'))
    … …  
    255255                                child_inode = Inode(self, newidx, Inode.TYPE_DIR)
    256256                                self.subtree_add(child_inode, inode, item.path)
    257                
     257
    258258                        dir_writer.add(child_inode.as_dirent(item.name))
    259259                        self.write_inode(child_inode)
    260260
    261261                dir_writer.finish()
    262        
     262
    263263        def write_inode(self, inode):
    264264                "Write inode information into the inode table"
    265                
     265
    266266                self.seek_to_inode(inode.index)
    267267                self.outf.write(inode.pack())
    … …  
    269269        def write_gdt(self):
    270270                "Write group descriptor table at the current file position"
    271                
     271
    272272                for gde in self.gdt:
    273273                        data = bytes(gde.pack())
    274274                        self.outf.write(data)
    275275                        self.outf.seek(GDE_SIZE-len(data), os.SEEK_CUR)
    276        
     276
    277277        def write_superblock(self, block_group):
    278278                "Write superblock at the current position"
    279                
     279
    280280                sb = xstruct.create(STRUCT_SUPERBLOCK)
    281281                sb.total_inode_count = self.total_inode_count
    … …  
    312312                sb.volume_name = 'HelenOS rdimage\0'
    313313                self.outf.write(bytes(sb.pack()))
    314        
     314
    315315        def write_all_metadata(self):
    316316                "Write superblocks, block group tables, block and inode bitmaps"
    317                
     317
    318318                bbpg = self.blocks_per_group // 8
    319319                bipg = self.inodes_per_group // 8
    320320                def window(arr, index, size):
    321321                        return arr[index * size:(index + 1) * size]
    322                
     322
    323323                for bg_index in xrange(len(self.gdt)):
    324324                        sbpos = self.superblock_positions[bg_index]
    325325                        sbblock = (sbpos + 1023) // self.block_size
    326326                        gde = self.gdt[bg_index]
    327                        
     327
    328328                        self.outf.seek(sbpos)
    329329                        self.write_superblock(bg_index)
    330                        
     330
    331331                        self.seek_to_block(sbblock+1)
    332332                        self.write_gdt()
    333                        
     333
    334334                        self.seek_to_block(gde.block_bitmap_block)
    335335                        self.outf.write(window(self.block_allocator.bitmap, bg_index, bbpg))
    336                        
     336
    337337                        self.seek_to_block(gde.inode_bitmap_block)
    338338                        self.outf.write(window(self.inode_allocator.bitmap, bg_index, bipg))
    339        
     339
    340340        def close(self):
    341341                "Write all remaining data to the filesystem and close the file"
    342                
     342
    343343                self.write_inode(self.root_inode)
    344344                self.write_inode(self.lost_plus_found)
    … …  
    354354                self.bitmap = array.array('B', [0] * (count // 8))
    355355                self.mark_cb = None
    356        
     356
    357357        def __contains__(self, item):
    358358                "Check if the item is already used"
    359                
     359
    360360                bitidx = item - self.base
    361361                return get_bit(self.bitmap[bitidx // 8], bitidx % 8)
    362        
     362
    363363        def alloc(self, **options):
    364364                "Allocate a new item"
    365                
     365
    366366                while self.nextidx < self.count and (self.base + self.nextidx) in self:
    367367                        self.nextidx += 1
    … …  
    372372                self.mark_used(item, **options)
    373373                return item
    374        
     374
    375375        def mark_used(self, item, **options):
    376376                "Mark the specified item as used"
    377                
     377
    378378                bitidx = item - self.base
    379379                if item in self:
    … …  
    384384                if self.mark_cb:
    385385                        self.mark_cb(item, **options)
    386        
     386
    387387        def mark_used_all(self, items, **options):
    388388                "Mark all specified items as used"
    389                
     389
    390390                for item in items:
    391391                        self.mark_used(item, **options)
    … …  
    395395        TYPE_DIR = 2
    396396        TYPE2MODE = {TYPE_FILE: 8, TYPE_DIR: 4}
    397        
     397
    398398        def __init__(self, fs, index, typ):
    399399                self.fs = fs
    … …  
    406406                self.type = typ
    407407                self.refcount = 0
    408        
     408
    409409        def as_dirent(self, name):
    410410                "Return a DirEntry corresponding to this inode"
    411411                self.refcount += 1
    412412                return DirEntry(name, self.index, self.type)
    413        
     413
    414414        def new_block(self, data=True):
    415415                "Get a new block index from allocator and count it here as belonging to the file"
    416                
     416
    417417                block = self.fs.block_allocator.alloc()
    418418                self.blocks += 1
    419419                return block
    420        
     420
    421421        def get_or_add_block(self, block):
    422422                "Get or add a real block to the file"
    423                
     423
    424424                if block < 12:
    425425                        return self.get_or_add_block_direct(block)
    426426                return self.get_or_add_block_indirect(block)
    427        
     427
    428428        def get_or_add_block_direct(self, block):
    429429                "Get or add a real block to the file (direct blocks)"
    430                
     430
    431431                if self.direct[block] == None:
    432432                        self.direct[block] = self.new_block()
    433433                return self.direct[block]
    434        
     434
    435435        def get_or_add_block_indirect(self, block):
    436436                "Get or add a real block to the file (indirect blocks)"
    437                
     437
    438438                # Determine the indirection level for the desired block
    439439                level = None
    … …  
    444444
    445445                assert level != None
    446        
     446
    447447                # Compute offsets for the topmost level
    448448                block_offset_in_level = block - self.fs.indirect_limits[level-1];
    … …  
    452452                current_block.block_id = self.indirect[level-1]
    453453                offset_in_block = block_offset_in_level // self.fs.indirect_blocks_per_level[level-1]
    454        
     454
    455455                # Navigate through other levels
    456456                while level > 0:
    457457                        assert offset_in_block < self.fs.block_ids_per_block
    458                        
     458
    459459                        level -= 1
    460                        
     460
    461461                        self.fs.seek_to_block(current_block.block_id, offset_in_block*4)
    462462                        current_block.unpack(self.fs.outf.read(4))
    463                        
     463
    464464                        if current_block.block_id == 0:
    465465                                # The block does not exist, so alloc one and write it there
    … …  
    467467                                current_block.block_id = self.new_block(data=(level==0))
    468468                                self.fs.outf.write(current_block.pack())
    469                
     469
    470470                        # If we are on the last level, break here as
    471471                        # there is no next level to visit
    472472                        if level == 0:
    473473                                break
    474                
     474
    475475                        # Visit the next level
    476476                        block_offset_in_level %= self.fs.indirect_blocks_per_level[level];
    … …  
    478478
    479479                return current_block.block_id
    480        
     480
    481481        def do_seek(self):
    482482                "Perform a seek to the position indicated by self.pos"
    483                
     483
    484484                block = self.pos // self.fs.block_size
    485485                real_block = self.get_or_add_block(block)
    486486                offset = self.pos % self.fs.block_size
    487487                self.fs.seek_to_block(real_block, offset)
    488                
     488
    489489        def write(self, data):
    490490                "Write a piece of data (arbitrarily long) as the contents of the inode"
    491                
     491
    492492                data_pos = 0
    493493                while data_pos < len(data):
    … …  
    499499                        data_pos += bytes_to_write
    500500                        self.size = max(self.pos, self.size)
    501        
     501
    502502        def align_size_to_block(self):
    503503                "Align the size of the inode up to block size"
    504                
     504
    505505                self.size = align_up(self.size, self.fs.block_size)
    506        
     506
    507507        def align_pos(self, bytes):
    508508                "Align the current position up to bytes boundary"
    509                
     509
    510510                self.pos = align_up(self.pos, bytes)
    511        
     511
    512512        def set_pos(self, pos):
    513513                "Set the current position"
    514                
     514
    515515                self.pos = pos
    516        
     516
    517517        def pack(self):
    518518                "Pack the inode structure and return the result"
    519                
     519
    520520                data = xstruct.create(STRUCT_INODE)
    521521                data.mode = (Inode.TYPE2MODE[self.type] << 12)
    … …  
    546546                data.group_id_high = 0
    547547                return data.pack()
    548                
     548
    549549class DirEntry:
    550550        "Represents a linked list directory entry"
    551        
     551
    552552        def __init__(self, name, inode, typ):
    553553                self.name = name.encode('UTF-8')
    … …  
    555555                self.skip = None
    556556                self.type = typ
    557        
     557
    558558        def size(self):
    559559                "Return size of the entry in bytes"
    560                
     560
    561561                return align_up(8 + len(self.name)+1, 4)
    562        
     562
    563563        def write(self, inode):
    564564                "Write the directory entry into the inode"
    565                
     565
    566566                head = xstruct.create(STRUCT_DIR_ENTRY_HEAD)
    567567                head.inode = self.inode
    … …  
    575575class DirWriter:
    576576        "Manages writing directory entries into an inode (alignment, etc.)"
    577        
     577
    578578        def __init__(self, inode):
    579579                self.pos = 0
    … …  
    581581                self.prev_entry = None
    582582                self.prev_pos = None
    583        
     583
    584584        def prev_write(self):
    585585                "Write a previously remembered entry"
    586                
     586
    587587                if self.prev_entry:
    588588                        self.prev_entry.skip = self.pos - self.prev_pos
    … …  
    590590                                self.prev_entry.write(self.inode)
    591591                                self.inode.set_pos(self.pos)
    592        
     592
    593593        def add(self, entry):
    594594                "Add a directory entry to the directory"
    595                
     595
    596596                size = entry.size()
    597597                block_size = self.inode.fs.block_size
    … …  
    602602                self.prev_pos = self.pos
    603603                self.pos += size
    604        
     604
    605605        def finish(self):
    606606                "Write the last entry and finish writing the directory contents"
    607                
     607
    608608                if not self.inode:
    609609                        return
    … …  
    614614def subtree_stats(root, block_size):
    615615        "Recursively calculate statistics"
    616        
     616
    617617        blocks = 0
    618618        inodes = 1
    619619        dir_writer = DirWriter(None)
    620        
     620
    621621        for item in listdir_items(root):
    622622                inodes += 1
    … …  
    627627                        blocks += subtree_blocks
    628628                        inodes += subtree_inodes
    629        
     629
    630630        dir_writer.finish()
    631631        blocks += count_up(dir_writer.pos, block_size)
    … …  
    640640                usage(sys.argv[0])
    641641                return
    642        
     642
    643643        if (not sys.argv[1].isdigit()):
    644644                print("<EXTRA_BYTES> must be a number")
    645645                return
    646        
     646
    647647        extra_bytes = int(sys.argv[1])
    648        
     648
    649649        path = os.path.abspath(sys.argv[2])
    650650        if (not os.path.isdir(path)):
    651651                print("<PATH> must be a directory")
    652652                return
    653        
     653
    654654        block_size = 4096
    655655        inode_size = 128
    … …  
    657657        blocks_per_group = 1024
    658658        inodes_per_group = 512
    659        
     659
    660660        blocks, inodes = subtree_stats(path, block_size)
    661661        blocks += count_up(extra_bytes, block_size)
    662662        inodes += reserved_inode_count
    663        
     663
    664664        inodes_per_group = align_up(inodes_per_group, 8)
    665665        blocks_per_group = align_up(blocks_per_group, 8)
    666        
     666
    667667        inode_table_blocks_per_group = (inodes_per_group * inode_size) // block_size
    668668        inode_bitmap_blocks_per_group = count_up(inodes_per_group // 8, block_size)
    … …  
    673673        free_blocks_per_group -= block_bitmap_blocks_per_group
    674674        free_blocks_per_group -= 10 # one for SB and some reserve for GDT
    675        
     675
    676676        block_groups = max(count_up(inodes, inodes_per_group), count_up(blocks, free_blocks_per_group))
    677        
     677
    678678        fs = Filesystem(sys.argv[3], block_groups, blocks_per_group, inodes_per_group,
    679679                                block_size, inode_size, reserved_inode_count)
    680        
     680
    681681        fs.subtree_add(fs.root_inode, fs.root_inode, path, is_root=True)
    682682        fs.close()
    683        
     683
    684684if __name__ == '__main__':
    685685        main()
Note: See TracChangeset for help on using the changeset viewer.