WebSVN – HelenOS – Diff – /branches/dynload/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
 
exclude_names = set(['.svn'])
 
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, dirent_size):
    "Recursive directory walk and calculate size"
   
    size = 0
    files = 2
   
    for name in os.listdir(root):
        canon = os.path.join(root, name)
       
        if (os.path.isfile(canon) and (not name in exclude_names)):
            size += align_up(os.path.getsize(canon), cluster_size)
            files += 1
       
        if (os.path.isdir(canon) and (not name in exclude_names)):
            size += subtree_size(canon, cluster_size, dirent_size)
            files += 1
   
    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, reserved_clusters):
    "Store the contents of a file"
   
    size = os.path.getsize(path)
    prev = -1
    first = 0
   
    inf = file(path, "r")
    rd = 0;
    while (rd < size):
        empty_cluster = fat.index(0)
        fat[empty_cluster] = 0xffff
       
        if (prev != -1):
            fat[prev] = empty_cluster
        else:
            first = empty_cluster
       
        prev = empty_cluster
       
        data = inf.read(cluster_size);
        outf.seek(data_start + (empty_cluster - reserved_clusters) * cluster_size)
        outf.write(data)
        rd += len(data)
    inf.close()
   
    return first, size
 
def write_directory(directory, outf, cluster_size, data_start, fat, reserved_clusters, dirent_size, empty_cluster):
    "Store the contents of a directory"
   
    length = len(directory)
    size = length * dirent_size
    prev = -1
    first = 0
   
    i = 0
    rd = 0;
    while (rd < size):
        if (prev != -1):
            empty_cluster = fat.index(0)
            fat[empty_cluster] = 0xffff
            fat[prev] = empty_cluster
        else:
            first = empty_cluster
       
        prev = empty_cluster
       
        data = ''
        data_len = 0
        while ((i < length) and (data_len < cluster_size)):
            if (i == 0):
                directory[i].cluster = empty_cluster
           
            data += directory[i].pack()
            data_len += dirent_size
            i += 1
       
        outf.seek(data_start + (empty_cluster - reserved_clusters) * cluster_size)
        outf.write(data)
        rd += len(data)
   
    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 */
"""
 
DOT_DIR_ENTRY = """little:
    uint8_t signature          /* 0x2e signature */
    char name[7]               /* empty */
    char ext[3]                /* empty */
    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 */
"""
 
DOTDOT_DIR_ENTRY = """little:
    uint8_t signature[2]       /* 0x2e signature */
    char name[6]               /* empty */
    char ext[3]                /* empty */
    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
    parts = name.split('.')
   
    if (len(parts) > 0):
        fname = parts[0]
    else:
        fname = ''
       
    return (fname + '          ').upper()[0:8]
 
def mangle_ext(name):
    # FIXME: filter illegal characters
    parts = name.split('.')
   
    if (len(parts) > 1):
        ext = parts[1]
    else:
        ext = ''
   
    return (ext + '   ').upper()[0:3]
 
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
   
    if (directory):
        dir_entry.size = 0
    else:
        dir_entry.size = size
   
    return dir_entry
 
def create_dot_dirent(empty_cluster):
    dir_entry = xstruct.create(DOT_DIR_ENTRY)
   
    dir_entry.signature = 0x2e
    dir_entry.name = '       '
    dir_entry.ext = '   '
    dir_entry.attr = 0x10
   
    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 = empty_cluster
    dir_entry.size = 0
   
    return dir_entry
 
def create_dotdot_dirent(parent_cluster):
    dir_entry = xstruct.create(DOTDOT_DIR_ENTRY)
   
    dir_entry.signature = [0x2e, 0x2e]
    dir_entry.name = '      '
    dir_entry.ext = '   '
    dir_entry.attr = 0x10
   
    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 = parent_cluster
    dir_entry.size = 0
   
    return dir_entry
 
def recursion(head, root, outf, cluster_size, root_start, data_start, fat, reserved_clusters, dirent_size, parent_cluster):
    "Recursive directory walk"
   
    directory = []
   
    if (not head):
        # Directory cluster preallocation
        empty_cluster = fat.index(0)
        fat[empty_cluster] = 0xffff
       
        directory.append(create_dot_dirent(empty_cluster))
        directory.append(create_dotdot_dirent(parent_cluster))
    else:
        empty_cluster = 0
   
    for name in os.listdir(root):
        canon = os.path.join(root, name)
       
        if (os.path.isfile(canon) and (not name in exclude_names)):
            rv = write_file(canon, outf, cluster_size, data_start, fat, reserved_clusters)
            directory.append(create_dirent(name, False, rv[0], rv[1]))
       
        if (os.path.isdir(canon) and (not name in exclude_names)):
            rv = recursion(False, canon, outf, cluster_size, root_start, data_start, fat, reserved_clusters, dirent_size, empty_cluster)
            directory.append(create_dirent(name, True, rv[0], rv[1]))
   
    if (head):
        outf.seek(root_start)
        for dir_entry in directory:
            outf.write(dir_entry.pack())
    else:
        return write_directory(directory, outf, cluster_size, data_start, fat, reserved_clusters, dirent_size, empty_cluster)
 
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]               /* 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:
            size = fat16_clusters * cluster_size + reserved_clusters * cluster_size
   
    root_size = align_up(root_entries(path) * dirent_size, cluster_size)
   
    fat_size = align_up(align_up(size, cluster_size) / cluster_size * fatent_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 = fat_count
    boot_sector.rootdir = root_size / dirent_size
    if (sectors <= 65535):
        boot_sector.sectors = sectors
    else:
        boot_sector.sectors = 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
    if (sectors > 65535):
        boot_sector.sectors_big = sectors
    else:
        boot_sector.sectors_big = 0
   
    boot_sector.drive = 0x80
    boot_sector.extboot_signature = 0x29
    boot_sector.serial = random.randint(0, 0x7fffffff)
    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
    for i in range(1, cluster_size / sector_size):
        outf.write(empty_sector.pack())
   
    # FAT tables
    for i in range(0, fat_count):
        for j in range(0, fat_size / sector_size):
            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, reserved_clusters, dirent_size, 0)
   
    # 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()
 

Rev 3535	Rev 3561
1	#!/usr/bin/env python	1	#!/usr/bin/env python
2	#	2	#
3	# Copyright (c) 2008 Martin Decky	3	# Copyright (c) 2008 Martin Decky
4	# All rights reserved.	4	# All rights reserved.
5	#	5	#
6	# Redistribution and use in source and binary forms, with or without	6	# Redistribution and use in source and binary forms, with or without
7	# modification, are permitted provided that the following conditions	7	# modification, are permitted provided that the following conditions
8	# are met:	8	# are met:
9	#	9	#
10	# - Redistributions of source code must retain the above copyright	10	# - Redistributions of source code must retain the above copyright
11	# notice, this list of conditions and the following disclaimer.	11	# notice, this list of conditions and the following disclaimer.
12	# - Redistributions in binary form must reproduce the above copyright	12	# - Redistributions in binary form must reproduce the above copyright
13	# notice, this list of conditions and the following disclaimer in the	13	# notice, this list of conditions and the following disclaimer in the
14	# documentation and/or other materials provided with the distribution.	14	# documentation and/or other materials provided with the distribution.
15	# - The name of the author may not be used to endorse or promote products	15	# - The name of the author may not be used to endorse or promote products
16	# derived from this software without specific prior written permission.	16	# derived from this software without specific prior written permission.
17	#	17	#
18	# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	18	# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19	# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES	19	# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20	# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	20	# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21	# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	21	# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22	# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	22	# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23	# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	23	# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24	# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	24	# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25	# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	25	# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26	# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF	26	# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27	# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	27	# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28	#	28	#
29	"""	29	"""
30	FAT creator	30	FAT creator
31	"""	31	"""
32		32
33	import sys	33	import sys
34	import os	34	import os
35	import random	35	import random
36	import xstruct	36	import xstruct
37	import array	37	import array
38		38
-		39	exclude_names = set(['.svn'])
-		40
39	def align_up(size, alignment):	41	def align_up(size, alignment):
40	"Return size aligned up to alignment"	42	"Return size aligned up to alignment"
41		43
42	if (size % alignment == 0):	44	if (size % alignment == 0):
43	return size	45	return size
44		46
45	return (((size / alignment) + 1) * alignment)	47	return (((size / alignment) + 1) * alignment)
46		48
47	def subtree_size(root, cluster_size, dirent_size):	49	def subtree_size(root, cluster_size, dirent_size):
48	"Recursive directory walk and calculate size"	50	"Recursive directory walk and calculate size"
49		51
50	size = 0	52	size = 0
51	files = 2	53	files = 2
52		54
53	for name in os.listdir(root):	55	for name in os.listdir(root):
54	canon = os.path.join(root, name)	56	canon = os.path.join(root, name)
55		57
56	if (os.path.isfile(canon)):	58	if (os.path.isfile(canon) and (not name in exclude_names)):
57	size += align_up(os.path.getsize(canon), cluster_size)	59	size += align_up(os.path.getsize(canon), cluster_size)
58	files += 1	60	files += 1
59		61
60	if (os.path.isdir(canon)):	62	if (os.path.isdir(canon) and (not name in exclude_names)):
61	size += subtree_size(canon, cluster_size, dirent_size)	63	size += subtree_size(canon, cluster_size, dirent_size)
62	files += 1	64	files += 1
63		65
64	return size + align_up(files * dirent_size, cluster_size)	66	return size + align_up(files * dirent_size, cluster_size)
65		67
66	def root_entries(root):	68	def root_entries(root):
67	"Return number of root directory entries"	69	"Return number of root directory entries"
68		70
69	return len(os.listdir(root))	71	return len(os.listdir(root))
70		72
71	def write_file(path, outf, cluster_size, data_start, fat, reserved_clusters):	73	def write_file(path, outf, cluster_size, data_start, fat, reserved_clusters):
72	"Store the contents of a file"	74	"Store the contents of a file"
73		75
74	size = os.path.getsize(path)	76	size = os.path.getsize(path)
75	prev = -1	77	prev = -1
76	first = 0	78	first = 0
77		79
78	inf = file(path, "r")	80	inf = file(path, "r")
79	rd = 0;	81	rd = 0;
80	while (rd < size):	82	while (rd < size):
81	empty_cluster = fat.index(0)	83	empty_cluster = fat.index(0)
82	fat[empty_cluster] = 0xffff	84	fat[empty_cluster] = 0xffff
83		85
84	if (prev != -1):	86	if (prev != -1):
85	fat[prev] = empty_cluster	87	fat[prev] = empty_cluster
86	else:	88	else:
87	first = empty_cluster	89	first = empty_cluster
88		90
89	prev = empty_cluster	91	prev = empty_cluster
90		92
91	data = inf.read(cluster_size);	93	data = inf.read(cluster_size);
92	outf.seek(data_start + (empty_cluster - reserved_clusters) * cluster_size)	94	outf.seek(data_start + (empty_cluster - reserved_clusters) * cluster_size)
93	outf.write(data)	95	outf.write(data)
94	rd += len(data)	96	rd += len(data)
95	inf.close()	97	inf.close()
96		98
97	return first, size	99	return first, size
98		100
99	def write_directory(directory, outf, cluster_size, data_start, fat, reserved_clusters, dirent_size, empty_cluster):	101	def write_directory(directory, outf, cluster_size, data_start, fat, reserved_clusters, dirent_size, empty_cluster):
100	"Store the contents of a directory"	102	"Store the contents of a directory"
101		103
102	length = len(directory)	104	length = len(directory)
103	size = length * dirent_size	105	size = length * dirent_size
104	prev = -1	106	prev = -1
105	first = 0	107	first = 0
106		108
107	i = 0	109	i = 0
108	rd = 0;	110	rd = 0;
109	while (rd < size):	111	while (rd < size):
110	if (prev != -1):	112	if (prev != -1):
111	empty_cluster = fat.index(0)	113	empty_cluster = fat.index(0)
112	fat[empty_cluster] = 0xffff	114	fat[empty_cluster] = 0xffff
113	fat[prev] = empty_cluster	115	fat[prev] = empty_cluster
114	else:	116	else:
115	first = empty_cluster	117	first = empty_cluster
116		118
117	prev = empty_cluster	119	prev = empty_cluster
118		120
119	data = ''	121	data = ''
120	data_len = 0	122	data_len = 0
121	while ((i < length) and (data_len < cluster_size)):	123	while ((i < length) and (data_len < cluster_size)):
122	if (i == 0):	124	if (i == 0):
123	directory[i].cluster = empty_cluster	125	directory[i].cluster = empty_cluster
124		126
125	data += directory[i].pack()	127	data += directory[i].pack()
126	data_len += dirent_size	128	data_len += dirent_size
127	i += 1	129	i += 1
128		130
129	outf.seek(data_start + (empty_cluster - reserved_clusters) * cluster_size)	131	outf.seek(data_start + (empty_cluster - reserved_clusters) * cluster_size)
130	outf.write(data)	132	outf.write(data)
131	rd += len(data)	133	rd += len(data)
132		134
133	return first, size	135	return first, size
134		136
135	DIR_ENTRY = """little:	137	DIR_ENTRY = """little:
136	char name[8] /* file name */	138	char name[8] /* file name */
137	char ext[3] /* file extension */	139	char ext[3] /* file extension */
138	uint8_t attr /* file attributes */	140	uint8_t attr /* file attributes */
139	padding[1] /* reserved for NT */	141	padding[1] /* reserved for NT */
140	uint8_t ctime_fine /* create time (fine resolution) */	142	uint8_t ctime_fine /* create time (fine resolution) */
141	uint16_t ctime /* create time */	143	uint16_t ctime /* create time */
142	uint16_t cdate /* create date */	144	uint16_t cdate /* create date */
143	uint16_t adate /* access date */	145	uint16_t adate /* access date */
144	padding[2] /* EA-index */	146	padding[2] /* EA-index */
145	uint16_t mtime /* modification time */	147	uint16_t mtime /* modification time */
146	uint16_t mdate /* modification date */	148	uint16_t mdate /* modification date */
147	uint16_t cluster /* first cluster */	149	uint16_t cluster /* first cluster */
148	uint32_t size /* file size */	150	uint32_t size /* file size */
149	"""	151	"""
150		152
151	DOT_DIR_ENTRY = """little:	153	DOT_DIR_ENTRY = """little:
152	uint8_t signature /* 0x2e signature */	154	uint8_t signature /* 0x2e signature */
153	char name[7] /* empty */	155	char name[7] /* empty */
154	char ext[3] /* empty */	156	char ext[3] /* empty */
155	uint8_t attr /* file attributes */	157	uint8_t attr /* file attributes */
156	padding[1] /* reserved for NT */	158	padding[1] /* reserved for NT */
157	uint8_t ctime_fine /* create time (fine resolution) */	159	uint8_t ctime_fine /* create time (fine resolution) */
158	uint16_t ctime /* create time */	160	uint16_t ctime /* create time */
159	uint16_t cdate /* create date */	161	uint16_t cdate /* create date */
160	uint16_t adate /* access date */	162	uint16_t adate /* access date */
161	padding[2] /* EA-index */	163	padding[2] /* EA-index */
162	uint16_t mtime /* modification time */	164	uint16_t mtime /* modification time */
163	uint16_t mdate /* modification date */	165	uint16_t mdate /* modification date */
164	uint16_t cluster /* first cluster */	166	uint16_t cluster /* first cluster */
165	uint32_t size /* file size */	167	uint32_t size /* file size */
166	"""	168	"""
167		169
168	DOTDOT_DIR_ENTRY = """little:	170	DOTDOT_DIR_ENTRY = """little:
169	uint8_t signature[2] /* 0x2e signature */	171	uint8_t signature[2] /* 0x2e signature */
170	char name[6] /* empty */	172	char name[6] /* empty */
171	char ext[3] /* empty */	173	char ext[3] /* empty */
172	uint8_t attr /* file attributes */	174	uint8_t attr /* file attributes */
173	padding[1] /* reserved for NT */	175	padding[1] /* reserved for NT */
174	uint8_t ctime_fine /* create time (fine resolution) */	176	uint8_t ctime_fine /* create time (fine resolution) */
175	uint16_t ctime /* create time */	177	uint16_t ctime /* create time */
176	uint16_t cdate /* create date */	178	uint16_t cdate /* create date */
177	uint16_t adate /* access date */	179	uint16_t adate /* access date */
178	padding[2] /* EA-index */	180	padding[2] /* EA-index */
179	uint16_t mtime /* modification time */	181	uint16_t mtime /* modification time */
180	uint16_t mdate /* modification date */	182	uint16_t mdate /* modification date */
181	uint16_t cluster /* first cluster */	183	uint16_t cluster /* first cluster */
182	uint32_t size /* file size */	184	uint32_t size /* file size */
183	"""	185	"""
184		186
185	def mangle_fname(name):	187	def mangle_fname(name):
186	# FIXME: filter illegal characters	188	# FIXME: filter illegal characters
187	parts = name.split('.')	189	parts = name.split('.')
188		190
189	if (len(parts) > 0):	191	if (len(parts) > 0):
190	fname = parts[0]	192	fname = parts[0]
191	else:	193	else:
192	fname = ''	194	fname = ''
193		195
194	return (fname + ' ').upper()[0:8]	196	return (fname + ' ').upper()[0:8]
195		197
196	def mangle_ext(name):	198	def mangle_ext(name):
197	# FIXME: filter illegal characters	199	# FIXME: filter illegal characters
198	parts = name.split('.')	200	parts = name.split('.')
199		201
200	if (len(parts) > 1):	202	if (len(parts) > 1):
201	ext = parts[1]	203	ext = parts[1]
202	else:	204	else:
203	ext = ''	205	ext = ''
204		206
205	return (ext + ' ').upper()[0:3]	207	return (ext + ' ').upper()[0:3]
206		208
207	def create_dirent(name, directory, cluster, size):	209	def create_dirent(name, directory, cluster, size):
208	dir_entry = xstruct.create(DIR_ENTRY)	210	dir_entry = xstruct.create(DIR_ENTRY)
209		211
210	dir_entry.name = mangle_fname(name)	212	dir_entry.name = mangle_fname(name)
211	dir_entry.ext = mangle_ext(name)	213	dir_entry.ext = mangle_ext(name)
212		214
213	if (directory):	215	if (directory):
214	dir_entry.attr = 0x30	216	dir_entry.attr = 0x30
215	else:	217	else:
216	dir_entry.attr = 0x20	218	dir_entry.attr = 0x20
217		219
218	dir_entry.ctime_fine = 0 # FIXME	220	dir_entry.ctime_fine = 0 # FIXME
219	dir_entry.ctime = 0 # FIXME	221	dir_entry.ctime = 0 # FIXME
220	dir_entry.cdate = 0 # FIXME	222	dir_entry.cdate = 0 # FIXME
221	dir_entry.adate = 0 # FIXME	223	dir_entry.adate = 0 # FIXME
222	dir_entry.mtime = 0 # FIXME	224	dir_entry.mtime = 0 # FIXME
223	dir_entry.mdate = 0 # FIXME	225	dir_entry.mdate = 0 # FIXME
224	dir_entry.cluster = cluster	226	dir_entry.cluster = cluster
225		227
226	if (directory):	228	if (directory):
227	dir_entry.size = 0	229	dir_entry.size = 0
228	else:	230	else:
229	dir_entry.size = size	231	dir_entry.size = size
230		232
231	return dir_entry	233	return dir_entry
232		234
233	def create_dot_dirent(empty_cluster):	235	def create_dot_dirent(empty_cluster):
234	dir_entry = xstruct.create(DOT_DIR_ENTRY)	236	dir_entry = xstruct.create(DOT_DIR_ENTRY)
235		237
236	dir_entry.signature = 0x2e	238	dir_entry.signature = 0x2e
237	dir_entry.name = ' '	239	dir_entry.name = ' '
238	dir_entry.ext = ' '	240	dir_entry.ext = ' '
239	dir_entry.attr = 0x10	241	dir_entry.attr = 0x10
240		242
241	dir_entry.ctime_fine = 0 # FIXME	243	dir_entry.ctime_fine = 0 # FIXME
242	dir_entry.ctime = 0 # FIXME	244	dir_entry.ctime = 0 # FIXME
243	dir_entry.cdate = 0 # FIXME	245	dir_entry.cdate = 0 # FIXME
244	dir_entry.adate = 0 # FIXME	246	dir_entry.adate = 0 # FIXME
245	dir_entry.mtime = 0 # FIXME	247	dir_entry.mtime = 0 # FIXME
246	dir_entry.mdate = 0 # FIXME	248	dir_entry.mdate = 0 # FIXME
247	dir_entry.cluster = empty_cluster	249	dir_entry.cluster = empty_cluster
248	dir_entry.size = 0	250	dir_entry.size = 0
249		251
250	return dir_entry	252	return dir_entry
251		253
252	def create_dotdot_dirent(parent_cluster):	254	def create_dotdot_dirent(parent_cluster):
253	dir_entry = xstruct.create(DOTDOT_DIR_ENTRY)	255	dir_entry = xstruct.create(DOTDOT_DIR_ENTRY)
254		256
255	dir_entry.signature = [0x2e, 0x2e]	257	dir_entry.signature = [0x2e, 0x2e]
256	dir_entry.name = ' '	258	dir_entry.name = ' '
257	dir_entry.ext = ' '	259	dir_entry.ext = ' '
258	dir_entry.attr = 0x10	260	dir_entry.attr = 0x10
259		261
260	dir_entry.ctime_fine = 0 # FIXME	262	dir_entry.ctime_fine = 0 # FIXME
261	dir_entry.ctime = 0 # FIXME	263	dir_entry.ctime = 0 # FIXME
262	dir_entry.cdate = 0 # FIXME	264	dir_entry.cdate = 0 # FIXME
263	dir_entry.adate = 0 # FIXME	265	dir_entry.adate = 0 # FIXME
264	dir_entry.mtime = 0 # FIXME	266	dir_entry.mtime = 0 # FIXME
265	dir_entry.mdate = 0 # FIXME	267	dir_entry.mdate = 0 # FIXME
266	dir_entry.cluster = parent_cluster	268	dir_entry.cluster = parent_cluster
267	dir_entry.size = 0	269	dir_entry.size = 0
268		270
269	return dir_entry	271	return dir_entry
270		272
271	def recursion(head, root, outf, cluster_size, root_start, data_start, fat, reserved_clusters, dirent_size, parent_cluster):	273	def recursion(head, root, outf, cluster_size, root_start, data_start, fat, reserved_clusters, dirent_size, parent_cluster):
272	"Recursive directory walk"	274	"Recursive directory walk"
273		275
274	directory = []	276	directory = []
275		277
276	if (not head):	278	if (not head):
277	# Directory cluster preallocation	279	# Directory cluster preallocation
278	empty_cluster = fat.index(0)	280	empty_cluster = fat.index(0)
279	fat[empty_cluster] = 0xffff	281	fat[empty_cluster] = 0xffff
280		282
281	directory.append(create_dot_dirent(empty_cluster))	283	directory.append(create_dot_dirent(empty_cluster))
282	directory.append(create_dotdot_dirent(parent_cluster))	284	directory.append(create_dotdot_dirent(parent_cluster))
283	else:	285	else:
284	empty_cluster = 0	286	empty_cluster = 0
285		287
286	for name in os.listdir(root):	288	for name in os.listdir(root):
287	canon = os.path.join(root, name)	289	canon = os.path.join(root, name)
288		290
289	if (os.path.isfile(canon)):	291	if (os.path.isfile(canon) and (not name in exclude_names)):
290	rv = write_file(canon, outf, cluster_size, data_start, fat, reserved_clusters)	292	rv = write_file(canon, outf, cluster_size, data_start, fat, reserved_clusters)
291	directory.append(create_dirent(name, False, rv[0], rv[1]))	293	directory.append(create_dirent(name, False, rv[0], rv[1]))
292		294
293	if (os.path.isdir(canon)):	295	if (os.path.isdir(canon) and (not name in exclude_names)):
294	rv = recursion(False, canon, outf, cluster_size, root_start, data_start, fat, reserved_clusters, dirent_size, empty_cluster)	296	rv = recursion(False, canon, outf, cluster_size, root_start, data_start, fat, reserved_clusters, dirent_size, empty_cluster)
295	directory.append(create_dirent(name, True, rv[0], rv[1]))	297	directory.append(create_dirent(name, True, rv[0], rv[1]))
296		298
297	if (head):	299	if (head):
298	outf.seek(root_start)	300	outf.seek(root_start)
299	for dir_entry in directory:	301	for dir_entry in directory:
300	outf.write(dir_entry.pack())	302	outf.write(dir_entry.pack())
301	else:	303	else:
302	return write_directory(directory, outf, cluster_size, data_start, fat, reserved_clusters, dirent_size, empty_cluster)	304	return write_directory(directory, outf, cluster_size, data_start, fat, reserved_clusters, dirent_size, empty_cluster)
303		305
304	BOOT_SECTOR = """little:	306	BOOT_SECTOR = """little:
305	uint8_t jmp[3] /* jump instruction */	307	uint8_t jmp[3] /* jump instruction */
306	char oem[8] /* OEM string */	308	char oem[8] /* OEM string */
307	uint16_t sector /* bytes per sector */	309	uint16_t sector /* bytes per sector */
308	uint8_t cluster /* sectors per cluster */	310	uint8_t cluster /* sectors per cluster */
309	uint16_t reserved /* reserved sectors */	311	uint16_t reserved /* reserved sectors */
310	uint8_t fats /* number of FATs */	312	uint8_t fats /* number of FATs */
311	uint16_t rootdir /* root directory entries */	313	uint16_t rootdir /* root directory entries */
312	uint16_t sectors /* total number of sectors */	314	uint16_t sectors /* total number of sectors */
313	uint8_t descriptor /* media descriptor */	315	uint8_t descriptor /* media descriptor */
314	uint16_t fat_sectors /* sectors per single FAT */	316	uint16_t fat_sectors /* sectors per single FAT */
315	uint16_t track_sectors /* sectors per track */	317	uint16_t track_sectors /* sectors per track */
316	uint16_t heads /* number of heads */	318	uint16_t heads /* number of heads */
317	uint32_t hidden /* hidden sectors */	319	uint32_t hidden /* hidden sectors */
318	uint32_t sectors_big /* total number of sectors (if sectors == 0) */	320	uint32_t sectors_big /* total number of sectors (if sectors == 0) */
319		321
320	/* Extended BIOS Parameter Block */	322	/* Extended BIOS Parameter Block */
321	uint8_t drive /* physical drive number */	323	uint8_t drive /* physical drive number */
322	padding[1] /* reserved (current head) */	324	padding[1] /* reserved (current head) */
323	uint8_t extboot_signature /* extended boot signature */	325	uint8_t extboot_signature /* extended boot signature */
324	uint32_t serial /* serial number */	326	uint32_t serial /* serial number */
325	char label[11] /* volume label */	327	char label[11] /* volume label */
326	char fstype[8] /* filesystem type */	328	char fstype[8] /* filesystem type */
327	padding[448] /* boot code */	329	padding[448] /* boot code */
328	uint8_t boot_signature[2] /* boot signature */	330	uint8_t boot_signature[2] /* boot signature */
329	"""	331	"""
330		332
331	EMPTY_SECTOR = """little:	333	EMPTY_SECTOR = """little:
332	padding[512] /* empty sector data */	334	padding[512] /* empty sector data */
333	"""	335	"""
334		336
335	FAT_ENTRY = """little:	337	FAT_ENTRY = """little:
336	uint16_t next /* FAT16 entry */	338	uint16_t next /* FAT16 entry */
337	"""	339	"""
338		340
339	def usage(prname):	341	def usage(prname):
340	"Print usage syntax"	342	"Print usage syntax"
341	print prname + " <PATH> <IMAGE>"	343	print prname + " <PATH> <IMAGE>"
342		344
343	def main():	345	def main():
344	if (len(sys.argv) < 3):	346	if (len(sys.argv) < 3):
345	usage(sys.argv[0])	347	usage(sys.argv[0])
346	return	348	return
347		349
348	path = os.path.abspath(sys.argv[1])	350	path = os.path.abspath(sys.argv[1])
349	if (not os.path.isdir(path)):	351	if (not os.path.isdir(path)):
350	print "<PATH> must be a directory"	352	print "<PATH> must be a directory"
351	return	353	return
352		354
353	fat16_clusters = 4096	355	fat16_clusters = 4096
354	min_cluster_size = 1024	-
355		356
356	sector_size = 512	357	sector_size = 512
357	cluster_size = 4096	358	cluster_size = 4096
358	dirent_size = 32	359	dirent_size = 32
359	fatent_size = 2	360	fatent_size = 2
360	fat_count = 2	361	fat_count = 2
361	reserved_clusters = 2	362	reserved_clusters = 2
362		363
363	# Make sure the filesystem is large enought for FAT16	364	# Make sure the filesystem is large enought for FAT16
364	size = subtree_size(path, cluster_size, dirent_size) + reserved_clusters * cluster_size	365	size = subtree_size(path, cluster_size, dirent_size) + reserved_clusters * cluster_size
365	while (size / cluster_size < fat16_clusters):	366	while (size / cluster_size < fat16_clusters):
366	if (cluster_size > min_cluster_size):	367	if (cluster_size > sector_size):
367	cluster_size /= 2	368	cluster_size /= 2
368	size = subtree_size(path, cluster_size, dirent_size) + reserved_clusters * cluster_size	369	size = subtree_size(path, cluster_size, dirent_size) + reserved_clusters * cluster_size
369	else:	370	else:
370	size = fat16_clusters * cluster_size + reserved_clusters * cluster_size	371	size = fat16_clusters * cluster_size + reserved_clusters * cluster_size
371		372
372	root_size = align_up(root_entries(path) * dirent_size, cluster_size)	373	root_size = align_up(root_entries(path) * dirent_size, cluster_size)
373		374
374	fat_size = align_up(align_up(size, cluster_size) / cluster_size * fatent_size, sector_size)	375	fat_size = align_up(align_up(size, cluster_size) / cluster_size * fatent_size, sector_size)
375		376
376	sectors = (cluster_size + fat_count * fat_size + root_size + size) / sector_size	377	sectors = (cluster_size + fat_count * fat_size + root_size + size) / sector_size
377	root_start = cluster_size + fat_count * fat_size	378	root_start = cluster_size + fat_count * fat_size
378	data_start = root_start + root_size	379	data_start = root_start + root_size
379		380
380	outf = file(sys.argv[2], "w")	381	outf = file(sys.argv[2], "w")
381		382
382	boot_sector = xstruct.create(BOOT_SECTOR)	383	boot_sector = xstruct.create(BOOT_SECTOR)
383	boot_sector.jmp = [0xEB, 0x3C, 0x90]	384	boot_sector.jmp = [0xEB, 0x3C, 0x90]
384	boot_sector.oem = "MSDOS5.0"	385	boot_sector.oem = "MSDOS5.0"
385	boot_sector.sector = sector_size	386	boot_sector.sector = sector_size
386	boot_sector.cluster = cluster_size / sector_size	387	boot_sector.cluster = cluster_size / sector_size
387	boot_sector.reserved = cluster_size / sector_size	388	boot_sector.reserved = cluster_size / sector_size
388	boot_sector.fats = fat_count	389	boot_sector.fats = fat_count
389	boot_sector.rootdir = root_size / dirent_size	390	boot_sector.rootdir = root_size / dirent_size
390	if (sectors <= 65535):	391	if (sectors <= 65535):
391	boot_sector.sectors = sectors	392	boot_sector.sectors = sectors
392	else:	393	else:
393	boot_sector.sectors = 0	394	boot_sector.sectors = 0
394	boot_sector.descriptor = 0xF8	395	boot_sector.descriptor = 0xF8
395	boot_sector.fat_sectors = fat_size / sector_size	396	boot_sector.fat_sectors = fat_size / sector_size
396	boot_sector.track_sectors = 63	397	boot_sector.track_sectors = 63
397	boot_sector.heads = 6	398	boot_sector.heads = 6
398	boot_sector.hidden = 0	399	boot_sector.hidden = 0
399	if (sectors > 65535):	400	if (sectors > 65535):
400	boot_sector.sectors_big = sectors	401	boot_sector.sectors_big = sectors
401	else:	402	else:
402	boot_sector.sectors_big = 0	403	boot_sector.sectors_big = 0
403		404
404	boot_sector.drive = 0x80	405	boot_sector.drive = 0x80
405	boot_sector.extboot_signature = 0x29	406	boot_sector.extboot_signature = 0x29
406	boot_sector.serial = random.randint(0, 0x7fffffff)	407	boot_sector.serial = random.randint(0, 0x7fffffff)
407	boot_sector.label = "HELENOS"	408	boot_sector.label = "HELENOS"
408	boot_sector.fstype = "FAT16 "	409	boot_sector.fstype = "FAT16 "
409	boot_sector.boot_signature = [0x55, 0xAA]	410	boot_sector.boot_signature = [0x55, 0xAA]
410		411
411	outf.write(boot_sector.pack())	412	outf.write(boot_sector.pack())
412		413
413	empty_sector = xstruct.create(EMPTY_SECTOR)	414	empty_sector = xstruct.create(EMPTY_SECTOR)
414		415
415	# Reserved sectors	416	# Reserved sectors
416	for i in range(1, cluster_size / sector_size):	417	for i in range(1, cluster_size / sector_size):
417	outf.write(empty_sector.pack())	418	outf.write(empty_sector.pack())
418		419
419	# FAT tables	420	# FAT tables
420	for i in range(0, fat_count):	421	for i in range(0, fat_count):
421	for j in range(0, fat_size / sector_size):	422	for j in range(0, fat_size / sector_size):
422	outf.write(empty_sector.pack())	423	outf.write(empty_sector.pack())
423		424
424	# Root directory	425	# Root directory
425	for i in range(0, root_size / sector_size):	426	for i in range(0, root_size / sector_size):
426	outf.write(empty_sector.pack())	427	outf.write(empty_sector.pack())
427		428
428	# Data	429	# Data
429	for i in range(0, size / sector_size):	430	for i in range(0, size / sector_size):
430	outf.write(empty_sector.pack())	431	outf.write(empty_sector.pack())
431		432
432	fat = array.array('L', [0] * (fat_size / fatent_size))	433	fat = array.array('L', [0] * (fat_size / fatent_size))
433	fat[0] = 0xfff8	434	fat[0] = 0xfff8
434	fat[1] = 0xffff	435	fat[1] = 0xffff
435		436
436	recursion(True, path, outf, cluster_size, root_start, data_start, fat, reserved_clusters, dirent_size, 0)	437	recursion(True, path, outf, cluster_size, root_start, data_start, fat, reserved_clusters, dirent_size, 0)
437		438
438	# Store FAT	439	# Store FAT
439	fat_entry = xstruct.create(FAT_ENTRY)	440	fat_entry = xstruct.create(FAT_ENTRY)
440	for i in range(0, fat_count):	441	for i in range(0, fat_count):
441	outf.seek(cluster_size + i * fat_size)	442	outf.seek(cluster_size + i * fat_size)
442	for j in range(0, fat_size / fatent_size):	443	for j in range(0, fat_size / fatent_size):
443	fat_entry.next = fat[j]	444	fat_entry.next = fat[j]
444	outf.write(fat_entry.pack())	445	outf.write(fat_entry.pack())
445		446
446	outf.close()	447	outf.close()
447		448
448	if __name__ == '__main__':	449	if __name__ == '__main__':
449	main()	450	main()
450		451

Subversion Repositories HelenOS

(root)/branches/dynload/tools/mkfat.py – Rev 3535 → 3561