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
 
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 3541	Rev 3545
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'])	39	exclude_names = set(['.svn'])
40		40
41	def align_up(size, alignment):	41	def align_up(size, alignment):
42	"Return size aligned up to alignment"	42	"Return size aligned up to alignment"
43		43
44	if (size % alignment == 0):	44	if (size % alignment == 0):
45	return size	45	return size
46		46
47	return (((size / alignment) + 1) * alignment)	47	return (((size / alignment) + 1) * alignment)
48		48
49	def subtree_size(root, cluster_size, dirent_size):	49	def subtree_size(root, cluster_size, dirent_size):
50	"Recursive directory walk and calculate size"	50	"Recursive directory walk and calculate size"
51		51
52	size = 0	52	size = 0
53	files = 2	53	files = 2
54		54
55	for name in os.listdir(root):	55	for name in os.listdir(root):
56	canon = os.path.join(root, name)	56	canon = os.path.join(root, name)
57		57
58	if (os.path.isfile(canon)):	58	if (os.path.isfile(canon) and (not name in exclude_names)):
59	size += align_up(os.path.getsize(canon), cluster_size)	59	size += align_up(os.path.getsize(canon), cluster_size)
60	files += 1	60	files += 1
61		61
62	if (os.path.isdir(canon)):	62	if (os.path.isdir(canon) and (not name in exclude_names)):
63	size += subtree_size(canon, cluster_size, dirent_size)	63	size += subtree_size(canon, cluster_size, dirent_size)
64	files += 1	64	files += 1
65		65
66	return size + align_up(files * dirent_size, cluster_size)	66	return size + align_up(files * dirent_size, cluster_size)
67		67
68	def root_entries(root):	68	def root_entries(root):
69	"Return number of root directory entries"	69	"Return number of root directory entries"
70		70
71	return len(os.listdir(root))	71	return len(os.listdir(root))
72		72
73	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):
74	"Store the contents of a file"	74	"Store the contents of a file"
75		75
76	size = os.path.getsize(path)	76	size = os.path.getsize(path)
77	prev = -1	77	prev = -1
78	first = 0	78	first = 0
79		79
80	inf = file(path, "r")	80	inf = file(path, "r")
81	rd = 0;	81	rd = 0;
82	while (rd < size):	82	while (rd < size):
83	empty_cluster = fat.index(0)	83	empty_cluster = fat.index(0)
84	fat[empty_cluster] = 0xffff	84	fat[empty_cluster] = 0xffff
85		85
86	if (prev != -1):	86	if (prev != -1):
87	fat[prev] = empty_cluster	87	fat[prev] = empty_cluster
88	else:	88	else:
89	first = empty_cluster	89	first = empty_cluster
90		90
91	prev = empty_cluster	91	prev = empty_cluster
92		92
93	data = inf.read(cluster_size);	93	data = inf.read(cluster_size);
94	outf.seek(data_start + (empty_cluster - reserved_clusters) * cluster_size)	94	outf.seek(data_start + (empty_cluster - reserved_clusters) * cluster_size)
95	outf.write(data)	95	outf.write(data)
96	rd += len(data)	96	rd += len(data)
97	inf.close()	97	inf.close()
98		98
99	return first, size	99	return first, size
100		100
101	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):
102	"Store the contents of a directory"	102	"Store the contents of a directory"
103		103
104	length = len(directory)	104	length = len(directory)
105	size = length * dirent_size	105	size = length * dirent_size
106	prev = -1	106	prev = -1
107	first = 0	107	first = 0
108		108
109	i = 0	109	i = 0
110	rd = 0;	110	rd = 0;
111	while (rd < size):	111	while (rd < size):
112	if (prev != -1):	112	if (prev != -1):
113	empty_cluster = fat.index(0)	113	empty_cluster = fat.index(0)
114	fat[empty_cluster] = 0xffff	114	fat[empty_cluster] = 0xffff
115	fat[prev] = empty_cluster	115	fat[prev] = empty_cluster
116	else:	116	else:
117	first = empty_cluster	117	first = empty_cluster
118		118
119	prev = empty_cluster	119	prev = empty_cluster
120		120
121	data = ''	121	data = ''
122	data_len = 0	122	data_len = 0
123	while ((i < length) and (data_len < cluster_size)):	123	while ((i < length) and (data_len < cluster_size)):
124	if (i == 0):	124	if (i == 0):
125	directory[i].cluster = empty_cluster	125	directory[i].cluster = empty_cluster
126		126
127	data += directory[i].pack()	127	data += directory[i].pack()
128	data_len += dirent_size	128	data_len += dirent_size
129	i += 1	129	i += 1
130		130
131	outf.seek(data_start + (empty_cluster - reserved_clusters) * cluster_size)	131	outf.seek(data_start + (empty_cluster - reserved_clusters) * cluster_size)
132	outf.write(data)	132	outf.write(data)
133	rd += len(data)	133	rd += len(data)
134		134
135	return first, size	135	return first, size
136		136
137	DIR_ENTRY = """little:	137	DIR_ENTRY = """little:
138	char name[8] /* file name */	138	char name[8] /* file name */
139	char ext[3] /* file extension */	139	char ext[3] /* file extension */
140	uint8_t attr /* file attributes */	140	uint8_t attr /* file attributes */
141	padding[1] /* reserved for NT */	141	padding[1] /* reserved for NT */
142	uint8_t ctime_fine /* create time (fine resolution) */	142	uint8_t ctime_fine /* create time (fine resolution) */
143	uint16_t ctime /* create time */	143	uint16_t ctime /* create time */
144	uint16_t cdate /* create date */	144	uint16_t cdate /* create date */
145	uint16_t adate /* access date */	145	uint16_t adate /* access date */
146	padding[2] /* EA-index */	146	padding[2] /* EA-index */
147	uint16_t mtime /* modification time */	147	uint16_t mtime /* modification time */
148	uint16_t mdate /* modification date */	148	uint16_t mdate /* modification date */
149	uint16_t cluster /* first cluster */	149	uint16_t cluster /* first cluster */
150	uint32_t size /* file size */	150	uint32_t size /* file size */
151	"""	151	"""
152		152
153	DOT_DIR_ENTRY = """little:	153	DOT_DIR_ENTRY = """little:
154	uint8_t signature /* 0x2e signature */	154	uint8_t signature /* 0x2e signature */
155	char name[7] /* empty */	155	char name[7] /* empty */
156	char ext[3] /* empty */	156	char ext[3] /* empty */
157	uint8_t attr /* file attributes */	157	uint8_t attr /* file attributes */
158	padding[1] /* reserved for NT */	158	padding[1] /* reserved for NT */
159	uint8_t ctime_fine /* create time (fine resolution) */	159	uint8_t ctime_fine /* create time (fine resolution) */
160	uint16_t ctime /* create time */	160	uint16_t ctime /* create time */
161	uint16_t cdate /* create date */	161	uint16_t cdate /* create date */
162	uint16_t adate /* access date */	162	uint16_t adate /* access date */
163	padding[2] /* EA-index */	163	padding[2] /* EA-index */
164	uint16_t mtime /* modification time */	164	uint16_t mtime /* modification time */
165	uint16_t mdate /* modification date */	165	uint16_t mdate /* modification date */
166	uint16_t cluster /* first cluster */	166	uint16_t cluster /* first cluster */
167	uint32_t size /* file size */	167	uint32_t size /* file size */
168	"""	168	"""
169		169
170	DOTDOT_DIR_ENTRY = """little:	170	DOTDOT_DIR_ENTRY = """little:
171	uint8_t signature[2] /* 0x2e signature */	171	uint8_t signature[2] /* 0x2e signature */
172	char name[6] /* empty */	172	char name[6] /* empty */
173	char ext[3] /* empty */	173	char ext[3] /* empty */
174	uint8_t attr /* file attributes */	174	uint8_t attr /* file attributes */
175	padding[1] /* reserved for NT */	175	padding[1] /* reserved for NT */
176	uint8_t ctime_fine /* create time (fine resolution) */	176	uint8_t ctime_fine /* create time (fine resolution) */
177	uint16_t ctime /* create time */	177	uint16_t ctime /* create time */
178	uint16_t cdate /* create date */	178	uint16_t cdate /* create date */
179	uint16_t adate /* access date */	179	uint16_t adate /* access date */
180	padding[2] /* EA-index */	180	padding[2] /* EA-index */
181	uint16_t mtime /* modification time */	181	uint16_t mtime /* modification time */
182	uint16_t mdate /* modification date */	182	uint16_t mdate /* modification date */
183	uint16_t cluster /* first cluster */	183	uint16_t cluster /* first cluster */
184	uint32_t size /* file size */	184	uint32_t size /* file size */
185	"""	185	"""
186		186
187	def mangle_fname(name):	187	def mangle_fname(name):
188	# FIXME: filter illegal characters	188	# FIXME: filter illegal characters
189	parts = name.split('.')	189	parts = name.split('.')
190		190
191	if (len(parts) > 0):	191	if (len(parts) > 0):
192	fname = parts[0]	192	fname = parts[0]
193	else:	193	else:
194	fname = ''	194	fname = ''
195		195
196	return (fname + ' ').upper()[0:8]	196	return (fname + ' ').upper()[0:8]
197		197
198	def mangle_ext(name):	198	def mangle_ext(name):
199	# FIXME: filter illegal characters	199	# FIXME: filter illegal characters
200	parts = name.split('.')	200	parts = name.split('.')
201		201
202	if (len(parts) > 1):	202	if (len(parts) > 1):
203	ext = parts[1]	203	ext = parts[1]
204	else:	204	else:
205	ext = ''	205	ext = ''
206		206
207	return (ext + ' ').upper()[0:3]	207	return (ext + ' ').upper()[0:3]
208		208
209	def create_dirent(name, directory, cluster, size):	209	def create_dirent(name, directory, cluster, size):
210	dir_entry = xstruct.create(DIR_ENTRY)	210	dir_entry = xstruct.create(DIR_ENTRY)
211		211
212	dir_entry.name = mangle_fname(name)	212	dir_entry.name = mangle_fname(name)
213	dir_entry.ext = mangle_ext(name)	213	dir_entry.ext = mangle_ext(name)
214		214
215	if (directory):	215	if (directory):
216	dir_entry.attr = 0x30	216	dir_entry.attr = 0x30
217	else:	217	else:
218	dir_entry.attr = 0x20	218	dir_entry.attr = 0x20
219		219
220	dir_entry.ctime_fine = 0 # FIXME	220	dir_entry.ctime_fine = 0 # FIXME
221	dir_entry.ctime = 0 # FIXME	221	dir_entry.ctime = 0 # FIXME
222	dir_entry.cdate = 0 # FIXME	222	dir_entry.cdate = 0 # FIXME
223	dir_entry.adate = 0 # FIXME	223	dir_entry.adate = 0 # FIXME
224	dir_entry.mtime = 0 # FIXME	224	dir_entry.mtime = 0 # FIXME
225	dir_entry.mdate = 0 # FIXME	225	dir_entry.mdate = 0 # FIXME
226	dir_entry.cluster = cluster	226	dir_entry.cluster = cluster
227		227
228	if (directory):	228	if (directory):
229	dir_entry.size = 0	229	dir_entry.size = 0
230	else:	230	else:
231	dir_entry.size = size	231	dir_entry.size = size
232		232
233	return dir_entry	233	return dir_entry
234		234
235	def create_dot_dirent(empty_cluster):	235	def create_dot_dirent(empty_cluster):
236	dir_entry = xstruct.create(DOT_DIR_ENTRY)	236	dir_entry = xstruct.create(DOT_DIR_ENTRY)
237		237
238	dir_entry.signature = 0x2e	238	dir_entry.signature = 0x2e
239	dir_entry.name = ' '	239	dir_entry.name = ' '
240	dir_entry.ext = ' '	240	dir_entry.ext = ' '
241	dir_entry.attr = 0x10	241	dir_entry.attr = 0x10
242		242
243	dir_entry.ctime_fine = 0 # FIXME	243	dir_entry.ctime_fine = 0 # FIXME
244	dir_entry.ctime = 0 # FIXME	244	dir_entry.ctime = 0 # FIXME
245	dir_entry.cdate = 0 # FIXME	245	dir_entry.cdate = 0 # FIXME
246	dir_entry.adate = 0 # FIXME	246	dir_entry.adate = 0 # FIXME
247	dir_entry.mtime = 0 # FIXME	247	dir_entry.mtime = 0 # FIXME
248	dir_entry.mdate = 0 # FIXME	248	dir_entry.mdate = 0 # FIXME
249	dir_entry.cluster = empty_cluster	249	dir_entry.cluster = empty_cluster
250	dir_entry.size = 0	250	dir_entry.size = 0
251		251
252	return dir_entry	252	return dir_entry
253		253
254	def create_dotdot_dirent(parent_cluster):	254	def create_dotdot_dirent(parent_cluster):
255	dir_entry = xstruct.create(DOTDOT_DIR_ENTRY)	255	dir_entry = xstruct.create(DOTDOT_DIR_ENTRY)
256		256
257	dir_entry.signature = [0x2e, 0x2e]	257	dir_entry.signature = [0x2e, 0x2e]
258	dir_entry.name = ' '	258	dir_entry.name = ' '
259	dir_entry.ext = ' '	259	dir_entry.ext = ' '
260	dir_entry.attr = 0x10	260	dir_entry.attr = 0x10
261		261
262	dir_entry.ctime_fine = 0 # FIXME	262	dir_entry.ctime_fine = 0 # FIXME
263	dir_entry.ctime = 0 # FIXME	263	dir_entry.ctime = 0 # FIXME
264	dir_entry.cdate = 0 # FIXME	264	dir_entry.cdate = 0 # FIXME
265	dir_entry.adate = 0 # FIXME	265	dir_entry.adate = 0 # FIXME
266	dir_entry.mtime = 0 # FIXME	266	dir_entry.mtime = 0 # FIXME
267	dir_entry.mdate = 0 # FIXME	267	dir_entry.mdate = 0 # FIXME
268	dir_entry.cluster = parent_cluster	268	dir_entry.cluster = parent_cluster
269	dir_entry.size = 0	269	dir_entry.size = 0
270		270
271	return dir_entry	271	return dir_entry
272		272
273	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):
274	"Recursive directory walk"	274	"Recursive directory walk"
275		275
276	directory = []	276	directory = []
277		277
278	if (not head):	278	if (not head):
279	# Directory cluster preallocation	279	# Directory cluster preallocation
280	empty_cluster = fat.index(0)	280	empty_cluster = fat.index(0)
281	fat[empty_cluster] = 0xffff	281	fat[empty_cluster] = 0xffff
282		282
283	directory.append(create_dot_dirent(empty_cluster))	283	directory.append(create_dot_dirent(empty_cluster))
284	directory.append(create_dotdot_dirent(parent_cluster))	284	directory.append(create_dotdot_dirent(parent_cluster))
285	else:	285	else:
286	empty_cluster = 0	286	empty_cluster = 0
287		287
288	for name in os.listdir(root):	288	for name in os.listdir(root):
289	canon = os.path.join(root, name)	289	canon = os.path.join(root, name)
290		290
291	if (os.path.isfile(canon) and (not name in exclude_names)):	291	if (os.path.isfile(canon) and (not name in exclude_names)):
292	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)
293	directory.append(create_dirent(name, False, rv[0], rv[1]))	293	directory.append(create_dirent(name, False, rv[0], rv[1]))
294		294
295	if (os.path.isdir(canon) and (not name in exclude_names)):	295	if (os.path.isdir(canon) and (not name in exclude_names)):
296	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)
297	directory.append(create_dirent(name, True, rv[0], rv[1]))	297	directory.append(create_dirent(name, True, rv[0], rv[1]))
298		298
299	if (head):	299	if (head):
300	outf.seek(root_start)	300	outf.seek(root_start)
301	for dir_entry in directory:	301	for dir_entry in directory:
302	outf.write(dir_entry.pack())	302	outf.write(dir_entry.pack())
303	else:	303	else:
304	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)
305		305
306	BOOT_SECTOR = """little:	306	BOOT_SECTOR = """little:
307	uint8_t jmp[3] /* jump instruction */	307	uint8_t jmp[3] /* jump instruction */
308	char oem[8] /* OEM string */	308	char oem[8] /* OEM string */
309	uint16_t sector /* bytes per sector */	309	uint16_t sector /* bytes per sector */
310	uint8_t cluster /* sectors per cluster */	310	uint8_t cluster /* sectors per cluster */
311	uint16_t reserved /* reserved sectors */	311	uint16_t reserved /* reserved sectors */
312	uint8_t fats /* number of FATs */	312	uint8_t fats /* number of FATs */
313	uint16_t rootdir /* root directory entries */	313	uint16_t rootdir /* root directory entries */
314	uint16_t sectors /* total number of sectors */	314	uint16_t sectors /* total number of sectors */
315	uint8_t descriptor /* media descriptor */	315	uint8_t descriptor /* media descriptor */
316	uint16_t fat_sectors /* sectors per single FAT */	316	uint16_t fat_sectors /* sectors per single FAT */
317	uint16_t track_sectors /* sectors per track */	317	uint16_t track_sectors /* sectors per track */
318	uint16_t heads /* number of heads */	318	uint16_t heads /* number of heads */
319	uint32_t hidden /* hidden sectors */	319	uint32_t hidden /* hidden sectors */
320	uint32_t sectors_big /* total number of sectors (if sectors == 0) */	320	uint32_t sectors_big /* total number of sectors (if sectors == 0) */
321		321
322	/* Extended BIOS Parameter Block */	322	/* Extended BIOS Parameter Block */
323	uint8_t drive /* physical drive number */	323	uint8_t drive /* physical drive number */
324	padding[1] /* reserved (current head) */	324	padding[1] /* reserved (current head) */
325	uint8_t extboot_signature /* extended boot signature */	325	uint8_t extboot_signature /* extended boot signature */
326	uint32_t serial /* serial number */	326	uint32_t serial /* serial number */
327	char label[11] /* volume label */	327	char label[11] /* volume label */
328	char fstype[8] /* filesystem type */	328	char fstype[8] /* filesystem type */
329	padding[448] /* boot code */	329	padding[448] /* boot code */
330	uint8_t boot_signature[2] /* boot signature */	330	uint8_t boot_signature[2] /* boot signature */
331	"""	331	"""
332		332
333	EMPTY_SECTOR = """little:	333	EMPTY_SECTOR = """little:
334	padding[512] /* empty sector data */	334	padding[512] /* empty sector data */
335	"""	335	"""
336		336
337	FAT_ENTRY = """little:	337	FAT_ENTRY = """little:
338	uint16_t next /* FAT16 entry */	338	uint16_t next /* FAT16 entry */
339	"""	339	"""
340		340
341	def usage(prname):	341	def usage(prname):
342	"Print usage syntax"	342	"Print usage syntax"
343	print prname + " <PATH> <IMAGE>"	343	print prname + " <PATH> <IMAGE>"
344		344
345	def main():	345	def main():
346	if (len(sys.argv) < 3):	346	if (len(sys.argv) < 3):
347	usage(sys.argv[0])	347	usage(sys.argv[0])
348	return	348	return
349		349
350	path = os.path.abspath(sys.argv[1])	350	path = os.path.abspath(sys.argv[1])
351	if (not os.path.isdir(path)):	351	if (not os.path.isdir(path)):
352	print "<PATH> must be a directory"	352	print "<PATH> must be a directory"
353	return	353	return
354		354
355	fat16_clusters = 4096	355	fat16_clusters = 4096
356	min_cluster_size = 1024	-
357		356
358	sector_size = 512	357	sector_size = 512
359	cluster_size = 4096	358	cluster_size = 4096
360	dirent_size = 32	359	dirent_size = 32
361	fatent_size = 2	360	fatent_size = 2
362	fat_count = 2	361	fat_count = 2
363	reserved_clusters = 2	362	reserved_clusters = 2
364		363
365	# Make sure the filesystem is large enought for FAT16	364	# Make sure the filesystem is large enought for FAT16
366	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
367	while (size / cluster_size < fat16_clusters):	366	while (size / cluster_size < fat16_clusters):
368	if (cluster_size > min_cluster_size):	367	if (cluster_size > sector_size):
369	cluster_size /= 2	368	cluster_size /= 2
370	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
371	else:	370	else:
372	size = fat16_clusters * cluster_size + reserved_clusters * cluster_size	371	size = fat16_clusters * cluster_size + reserved_clusters * cluster_size
373		372
374	root_size = align_up(root_entries(path) * dirent_size, cluster_size)	373	root_size = align_up(root_entries(path) * dirent_size, cluster_size)
375		374
376	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)
377		376
378	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
379	root_start = cluster_size + fat_count * fat_size	378	root_start = cluster_size + fat_count * fat_size
380	data_start = root_start + root_size	379	data_start = root_start + root_size
381		380
382	outf = file(sys.argv[2], "w")	381	outf = file(sys.argv[2], "w")
383		382
384	boot_sector = xstruct.create(BOOT_SECTOR)	383	boot_sector = xstruct.create(BOOT_SECTOR)
385	boot_sector.jmp = [0xEB, 0x3C, 0x90]	384	boot_sector.jmp = [0xEB, 0x3C, 0x90]
386	boot_sector.oem = "MSDOS5.0"	385	boot_sector.oem = "MSDOS5.0"
387	boot_sector.sector = sector_size	386	boot_sector.sector = sector_size
388	boot_sector.cluster = cluster_size / sector_size	387	boot_sector.cluster = cluster_size / sector_size
389	boot_sector.reserved = cluster_size / sector_size	388	boot_sector.reserved = cluster_size / sector_size
390	boot_sector.fats = fat_count	389	boot_sector.fats = fat_count
391	boot_sector.rootdir = root_size / dirent_size	390	boot_sector.rootdir = root_size / dirent_size
392	if (sectors <= 65535):	391	if (sectors <= 65535):
393	boot_sector.sectors = sectors	392	boot_sector.sectors = sectors
394	else:	393	else:
395	boot_sector.sectors = 0	394	boot_sector.sectors = 0
396	boot_sector.descriptor = 0xF8	395	boot_sector.descriptor = 0xF8
397	boot_sector.fat_sectors = fat_size / sector_size	396	boot_sector.fat_sectors = fat_size / sector_size
398	boot_sector.track_sectors = 63	397	boot_sector.track_sectors = 63
399	boot_sector.heads = 6	398	boot_sector.heads = 6
400	boot_sector.hidden = 0	399	boot_sector.hidden = 0
401	if (sectors > 65535):	400	if (sectors > 65535):
402	boot_sector.sectors_big = sectors	401	boot_sector.sectors_big = sectors
403	else:	402	else:
404	boot_sector.sectors_big = 0	403	boot_sector.sectors_big = 0
405		404
406	boot_sector.drive = 0x80	405	boot_sector.drive = 0x80
407	boot_sector.extboot_signature = 0x29	406	boot_sector.extboot_signature = 0x29
408	boot_sector.serial = random.randint(0, 0x7fffffff)	407	boot_sector.serial = random.randint(0, 0x7fffffff)
409	boot_sector.label = "HELENOS"	408	boot_sector.label = "HELENOS"
410	boot_sector.fstype = "FAT16 "	409	boot_sector.fstype = "FAT16 "
411	boot_sector.boot_signature = [0x55, 0xAA]	410	boot_sector.boot_signature = [0x55, 0xAA]
412		411
413	outf.write(boot_sector.pack())	412	outf.write(boot_sector.pack())
414		413
415	empty_sector = xstruct.create(EMPTY_SECTOR)	414	empty_sector = xstruct.create(EMPTY_SECTOR)
416		415
417	# Reserved sectors	416	# Reserved sectors
418	for i in range(1, cluster_size / sector_size):	417	for i in range(1, cluster_size / sector_size):
419	outf.write(empty_sector.pack())	418	outf.write(empty_sector.pack())
420		419
421	# FAT tables	420	# FAT tables
422	for i in range(0, fat_count):	421	for i in range(0, fat_count):
423	for j in range(0, fat_size / sector_size):	422	for j in range(0, fat_size / sector_size):
424	outf.write(empty_sector.pack())	423	outf.write(empty_sector.pack())
425		424
426	# Root directory	425	# Root directory
427	for i in range(0, root_size / sector_size):	426	for i in range(0, root_size / sector_size):
428	outf.write(empty_sector.pack())	427	outf.write(empty_sector.pack())
429		428
430	# Data	429	# Data
431	for i in range(0, size / sector_size):	430	for i in range(0, size / sector_size):
432	outf.write(empty_sector.pack())	431	outf.write(empty_sector.pack())
433		432
434	fat = array.array('L', [0] * (fat_size / fatent_size))	433	fat = array.array('L', [0] * (fat_size / fatent_size))
435	fat[0] = 0xfff8	434	fat[0] = 0xfff8
436	fat[1] = 0xffff	435	fat[1] = 0xffff
437		436
438	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)
439		438
440	# Store FAT	439	# Store FAT
441	fat_entry = xstruct.create(FAT_ENTRY)	440	fat_entry = xstruct.create(FAT_ENTRY)
442	for i in range(0, fat_count):	441	for i in range(0, fat_count):
443	outf.seek(cluster_size + i * fat_size)	442	outf.seek(cluster_size + i * fat_size)
444	for j in range(0, fat_size / fatent_size):	443	for j in range(0, fat_size / fatent_size):
445	fat_entry.next = fat[j]	444	fat_entry.next = fat[j]
446	outf.write(fat_entry.pack())	445	outf.write(fat_entry.pack())
447		446
448	outf.close()	447	outf.close()
449		448
450	if __name__ == '__main__':	449	if __name__ == '__main__':
451	main()	450	main()
452		451

Subversion Repositories HelenOS

(root)/trunk/tools/mkfat.py – Rev 3541 → 3545