Subversion Repositories HelenOS

#!/usr/bin/env python

#

# Copyright (c) 2008 Martin Decky

# All rights reserved.

#

# Redistribution and use in source and binary forms, with or without

# modification, are permitted provided that the following conditions

# are met:

#

# - Redistributions of source code must retain the above copyright

#   notice, this list of conditions and the following disclaimer.

# - Redistributions in binary form must reproduce the above copyright

#   notice, this list of conditions and the following disclaimer in the

#   documentation and/or other materials provided with the distribution.

# - The name of the author may not be used to endorse or promote products

#   derived from this software without specific prior written permission.

#

# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR

# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.

# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,

# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#

"""

FAT creator

"""

import sys

import os

import random

import xstruct

import array

def align_up(size, alignment):

	"Return size aligned up to alignment"

	if (size % alignment == 0):

		return size

	return (((size / alignment) + 1) * alignment)

def subtree_size(root, cluster_size, dirent_size):

	"Recursive directory walk and calculate size"

	size = 0

	files = 0

	for name in os.listdir(root):

		canon = os.path.join(root, name)

		if (os.path.isfile(canon)):

			size += align_up(os.path.getsize(canon), cluster_size)

			files += 1

		if (os.path.isdir(canon)):

			size += subtree_size(canon, cluster_size, 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):

	"Store the contents of a file"

	size = os.path.getsize(path)

	prev = -1

	first = -1

	inf = file(path, "r")

	rd = 0;

	while (rd < size):

		data = inf.read(cluster_size);

		empty_cluster = fat.index(0)

		fat[empty_cluster] = 0xffff

		if (prev != -1):

			fat[prev] = empty_cluster

		else:

			first = empty_cluster

		prev = empty_cluster

		outf.seek(data_start + empty_cluster * cluster_size)

		outf.write(data)

		rd += len(data)

	inf.close()

	return first, size

DIR_ENTRY = """little:

	char name[8]               /* file name */

	char ext[3]                /* file extension */

	uint8_t attr               /* file attributes */

	padding[1]                 /* reserved for NT */

	uint8_t ctime_fine         /* create time (fine resolution) */

	uint16_t ctime             /* create time */

	uint16_t cdate             /* create date */

	uint16_t adate             /* access date */

	padding[2]                 /* EA-index */

	uint16_t mtime             /* modification time */

	uint16_t mdate             /* modification date */

	uint16_t cluster           /* first cluster */

	uint32_t size              /* file size */

"""

def mangle_fname(name):

	# FIXME: filter illegal characters

	fname = (name.split('.')[0] + '          ').upper()[0:8]

	return fname

def mangle_ext(name):

	# FIXME: filter illegal characters

	ext = (name.split('.')[1] + '  ').upper()[0:3]

	return ext

def create_dirent(name, directory, cluster, size):

	dir_entry = xstruct.create(DIR_ENTRY)

	dir_entry.name = mangle_fname(name)

	dir_entry.ext = mangle_ext(name)

	if (directory):

		dir_entry.attr = 0x30

	else:

		dir_entry.attr = 0x20

	dir_entry.ctime_fine = 0 # FIXME

	dir_entry.ctime = 0 # FIXME

	dir_entry.cdate = 0 # FIXME

	dir_entry.adate = 0 # FIXME

	dir_entry.mtime = 0 # FIXME

	dir_entry.mdate = 0 # FIXME

	dir_entry.cluster = cluster

	dir_entry.size = size

	return dir_entry

def recursion(head, root, outf, cluster_size, root_start, data_start, fat):

	"Recursive directory walk"

	directory = []

	for name in os.listdir(root):

		canon = os.path.join(root, name)

		if (os.path.isfile(canon)):

			rv = write_file(canon, outf, cluster_size, data_start, fat)

			directory.append(create_dirent(name, False, rv[0], rv[1]))

	if (head):

		outf.seek(root_start)

		for dir_entry in directory:

			outf.write(dir_entry.pack())

BOOT_SECTOR = """little:

	uint8_t jmp[3]             /* jump instruction */

	char oem[8]                /* OEM string */

	uint16_t sector            /* bytes per sector */

	uint8_t cluster            /* sectors per cluster */

	uint16_t reserved          /* reserved sectors */

	uint8_t fats               /* number of FATs */

	uint16_t rootdir           /* root directory entries */

	uint16_t sectors           /* total number of sectors */

	uint8_t descriptor         /* media descriptor */

	uint16_t fat_sectors       /* sectors per single FAT */

	uint16_t track_sectors     /* sectors per track */

	uint16_t heads             /* number of heads */

	uint32_t hidden            /* hidden sectors */

	uint32_t sectors_big       /* total number of sectors (if sectors == 0) */

	/* Extended BIOS Parameter Block */

	uint8_t drive              /* physical drive number */

	padding[1]                 /* reserved (current head) */

	uint8_t extboot_signature  /* extended boot signature */

	uint32_t serial            /* serial number */

	char label[11]             /* volume label */

	char fstype[8]             /* filesystem type */

	padding[448]               /* boot code */

	uint8_t boot_signature[2]  /* boot signature */

"""

EMPTY_SECTOR = """little:

	padding[512]               /* 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

	boot_sector.sectors = (sectors if (sectors <= 65535) else 0)

	boot_sector.descriptor = 0xF8

	boot_sector.fat_sectors = fat_size / sector_size

	boot_sector.track_sectors = 63

	boot_sector.heads = 6

	boot_sector.hidden = 0

	boot_sector.sectors_big = (sectors if (sectors > 65535) else 0)

	boot_sector.drive = 0x80

	boot_sector.extboot_signature = 0x29

	boot_sector.serial = random.randint(0, 0xFFFFFFFF)

	boot_sector.label = "HELENOS"

	boot_sector.fstype = "FAT16   "

	boot_sector.boot_signature = [0x55, 0xAA]

	outf.write(boot_sector.pack())

	empty_sector = xstruct.create(EMPTY_SECTOR)

	# Reserved sectors

	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, boot_sector.fat_sectors):

			outf.write(empty_sector.pack())

	# Root directory

	for i in range(0, root_size / sector_size):

		outf.write(empty_sector.pack())

	# Data

	for i in range(0, size / sector_size):

		outf.write(empty_sector.pack())

	fat = array.array('L', [0] * (fat_size / fatent_size))

	fat[0] = 0xfff8

	fat[1] = 0xffff

	recursion(True, path, outf, cluster_size, root_start, data_start, fat)

	# Store FAT

	fat_entry = xstruct.create(FAT_ENTRY)

	for i in range(0, fat_count):

		outf.seek(cluster_size + i * fat_size)

		for j in range(0, fat_size / fatent_size):

			fat_entry.next = fat[j]

			outf.write(fat_entry.pack())

	outf.close()

if __name__ == '__main__':

	main()