Context Navigation

source: mainline/tools/mkfat.py@ c621f4aa

Visit:

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export

Last change on this file since c621f4aa was 3c80f2b, checked in by Martin Decky <martin@…>, 15 years ago
Python coding style cleanup (no change in functionality)
Property mode set to `100755`
File size: 13.0 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: