WebSVN – HelenOS – Diff – /trunk/tools/mkfat.py

 #!/usr/bin/env python
+#
 # Copyright (c) 2008 Martin Decky
 # 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.
 # - The name of the author may not be used to endorse or promote products
 #   derived from this software without specific prior written permission.
+#
 # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+#
 """
 FAT creator
 """
 import sys
 import os
 import random
 import xstruct
+import array
 def align_up(size, alignment):
     "Return size aligned up to alignment"
     if (size % alignment == 0):
         return size
     return (((size / alignment) + 1) * alignment)
-def subtree_size(root, cluster_size):
+def subtree_size(root, cluster_size, dirent_size):
     "Recursive directory walk and calculate size"
     size = 0
     files = 0
     for name in os.listdir(root):
         canon = os.path.join(root, name)
         if (os.path.isfile(canon)):
             size += align_up(os.path.getsize(canon), cluster_size)
             files += 1
         if (os.path.isdir(canon)):
-            size += subtree_size(canon, cluster_size)
+            size += subtree_size(canon, cluster_size, dirent_size)
             files += 1
-    return size + align_up(files * 32, cluster_size)
+    return size + align_up(files * dirent_size, cluster_size)
 def root_entries(root):
     "Return number of root directory entries"
     return len(os.listdir(root))
+def write_file(path, outf, cluster_size, data_start, fat):
+    "Store the contents of a file"
+    size = os.path.getsize(path)
+    prev = -1
+    first = -1
+    inf = file(path, "r")
+    rd = 0;
+    while (rd < size):
+        data = inf.read(cluster_size);
+        empty_cluster = fat.index(0)
+        fat[empty_cluster] = 0xffff
+        if (prev != -1):
+            fat[prev] = empty_cluster
+        else:
+            first = empty_cluster
+        prev = empty_cluster
+        outf.seek(data_start + empty_cluster * cluster_size)
+        outf.write(data)
+        rd += len(data)
+    inf.close()
+    return first, size
+DIR_ENTRY = """little:
+    char name[8]               /* file name */
+    char ext[3]                /* file extension */
+    uint8_t attr               /* file attributes */
+    padding[1]                 /* reserved for NT */
+    uint8_t ctime_fine         /* create time (fine resolution) */
+    uint16_t ctime             /* create time */
+    uint16_t cdate             /* create date */
+    uint16_t adate             /* access date */
+    padding[2]                 /* EA-index */
+    uint16_t mtime             /* modification time */
+    uint16_t mdate             /* modification date */
+    uint16_t cluster           /* first cluster */
+    uint32_t size              /* file size */
+"""
+def mangle_fname(name):
+    # FIXME: filter illegal characters
+    fname = (name.split('.')[0] + '          ').upper()[0:8]
+    return fname
+def mangle_ext(name):
+    # FIXME: filter illegal characters
+    ext = (name.split('.')[1] + '  ').upper()[0:3]
+    return ext
+def create_dirent(name, directory, cluster, size):
+    dir_entry = xstruct.create(DIR_ENTRY)
+    dir_entry.name = mangle_fname(name)
+    dir_entry.ext = mangle_ext(name)
+    if (directory):
+        dir_entry.attr = 0x30
+    else:
+        dir_entry.attr = 0x20
+    dir_entry.ctime_fine = 0 # FIXME
+    dir_entry.ctime = 0 # FIXME
+    dir_entry.cdate = 0 # FIXME
+    dir_entry.adate = 0 # FIXME
+    dir_entry.mtime = 0 # FIXME
+    dir_entry.mdate = 0 # FIXME
+    dir_entry.cluster = cluster
+    dir_entry.size = size
+    return dir_entry
+def recursion(head, root, outf, cluster_size, root_start, data_start, fat):
+    "Recursive directory walk"
+    directory = []
+    for name in os.listdir(root):
+        canon = os.path.join(root, name)
+        if (os.path.isfile(canon)):
+            rv = write_file(canon, outf, cluster_size, data_start, fat)
+            directory.append(create_dirent(name, False, rv[0], rv[1]))
+    if (head):
+        outf.seek(root_start)
+        for dir_entry in directory:
+            outf.write(dir_entry.pack())
 BOOT_SECTOR = """little:
     uint8_t jmp[3]             /* jump instruction */
     char oem[8]                /* OEM string */
     uint16_t sector            /* bytes per sector */
     uint8_t cluster            /* sectors per cluster */
     uint16_t reserved          /* reserved sectors */
     uint8_t fats               /* number of FATs */
     uint16_t rootdir           /* root directory entries */
     uint16_t sectors           /* total number of sectors */
     uint8_t descriptor         /* media descriptor */
     uint16_t fat_sectors       /* sectors per single FAT */
     uint16_t track_sectors     /* sectors per track */
     uint16_t heads             /* number of heads */
     uint32_t hidden            /* hidden sectors */
     uint32_t sectors_big       /* total number of sectors (if sectors == 0) */
     /* Extended BIOS Parameter Block */
     uint8_t drive              /* physical drive number */
     padding[1]                 /* reserved (current head) */
     uint8_t extboot_signature  /* extended boot signature */
     uint32_t serial            /* serial number */
     char label[11]             /* volume label */
     char fstype[8]             /* filesystem type */
     padding[448]               /* boot code */
     uint8_t boot_signature[2]  /* boot signature */
 """
 EMPTY_SECTOR = """little:
-    padding[512]
+    padding[512]               /* empty sector data */
+"""
+FAT_ENTRY = """little:
+    uint16_t next              /* FAT16 entry */
 """
 def usage(prname):
     "Print usage syntax"
     print prname + " <PATH> <IMAGE>"
 def main():
     if (len(sys.argv) < 3):
         usage(sys.argv[0])
         return
     path = os.path.abspath(sys.argv[1])
     if (not os.path.isdir(path)):
         print "<PATH> must be a directory"
         return
+    fat16_clusters = 4096
     sector_size = 512
     cluster_size = 4096
+    dirent_size = 32
+    fatent_size = 2
+    fat_count = 2
+    reserved_clusters = 2
+    # Make sure the filesystem is large enought for FAT16
+    size = subtree_size(path, cluster_size, dirent_size) + reserved_clusters * cluster_size
+    while (size / cluster_size < fat16_clusters):
+        if (cluster_size > sector_size):
+            cluster_size /= 2
+            size = subtree_size(path, cluster_size, dirent_size) + reserved_clusters * cluster_size
+        else:
-    root_size = align_up(root_entries(sys.argv[1]) * 32, sector_size)
+            size = fat16_clusters * cluster_size + reserved_clusters * cluster_size
-    size = subtree_size(sys.argv[1], cluster_size)
+    root_size = align_up(root_entries(path) * dirent_size, cluster_size)
-    fat_size = align_up(size / cluster_size * 2, sector_size)
+    fat_size = align_up(align_up(size, cluster_size) / cluster_size * fatent_size, sector_size)
-    sectors = (cluster_size + 2 * fat_size + root_size + size) / sector_size
+    sectors = (cluster_size + fat_count * fat_size + root_size + size) / sector_size
+    root_start = cluster_size + fat_count * fat_size
+    data_start = root_start + root_size
     outf = file(sys.argv[2], "w")
     boot_sector = xstruct.create(BOOT_SECTOR)
     boot_sector.jmp = [0xEB, 0x3C, 0x90]
     boot_sector.oem = "MSDOS5.0"
     boot_sector.sector = sector_size
     boot_sector.cluster = cluster_size / sector_size
     boot_sector.reserved = cluster_size / sector_size
-    boot_sector.fats = 2
+    boot_sector.fats = fat_count
-    boot_sector.rootdir = root_size / 32
+    boot_sector.rootdir = root_size / dirent_size
     boot_sector.sectors = (sectors if (sectors <= 65535) else 0)
     boot_sector.descriptor = 0xF8
     boot_sector.fat_sectors = fat_size / sector_size
     boot_sector.track_sectors = 63
     boot_sector.heads = 6
     boot_sector.hidden = 0
     boot_sector.sectors_big = (sectors if (sectors > 65535) else 0)
     boot_sector.drive = 0x80
     boot_sector.extboot_signature = 0x29
     boot_sector.serial = random.randint(0, 0xFFFFFFFF)
     boot_sector.label = "HELENOS"
     boot_sector.fstype = "FAT16   "
     boot_sector.boot_signature = [0x55, 0xAA]
     outf.write(boot_sector.pack())
     empty_sector = xstruct.create(EMPTY_SECTOR)
-    # Reserved sectors (boot_sector.reserved - boot_sector)
+    # Reserved sectors
-    for i in range(1, boot_sector.reserved):
+    for i in range(1, cluster_size / sector_size):
         outf.write(empty_sector.pack())
     # FAT tables
-    for i in range(0, boot_sector.fats):
+    for i in range(0, fat_count):
         for j in range(0, boot_sector.fat_sectors):
             outf.write(empty_sector.pack())
     # Root directory
     for i in range(0, root_size / sector_size):
         outf.write(empty_sector.pack())
     # Data
     for i in range(0, size / sector_size):
         outf.write(empty_sector.pack())
+    fat = array.array('L', [0] * (fat_size / fatent_size))
+    fat[0] = 0xfff8
+    fat[1] = 0xffff
+    recursion(True, path, outf, cluster_size, root_start, data_start, fat)
+    # Store FAT
+    fat_entry = xstruct.create(FAT_ENTRY)
+    for i in range(0, fat_count):
+        outf.seek(cluster_size + i * fat_size)
+        for j in range(0, fat_size / fatent_size):
+            fat_entry.next = fat[j]
+            outf.write(fat_entry.pack())
     outf.close()
 if __name__ == '__main__':
     main()

Subversion Repositories HelenOS

(root)/trunk/tools/mkfat.py – Rev 3511 → 3520