Squash commits for public release

utils/legacy/config.py

@@ -0,0 +1,9 @@
+format_settings = {
+    'BytesPerSector': 0x200, # 512
+    'SectorPerClustor': 0x1, # 1
+    'ReservedSectors': 200 , # 100 kb
+    'NumberOfFATs': 0x2,
+    'RootEntires': 0x200,
+    'VolumeName': 'xOSHD',
+    'filename': 'one.img'
+}

utils/legacy/copy_bin.py

@@ -0,0 +1,112 @@
+from config import *
+
+copyTo = 'one.img'
+copyFrom = 'products/kernel.bin'
+kernelSize = 0
+
+def open_file():
+    global kernelSize
+    kernelSize = 0
+    # dd = [0, 0]
+    dd = []
+
+    with open(copyFrom, "rb") as f:
+        byte = f.read(1)
+        dd.append(int.from_bytes(byte, byteorder='little'))
+        kernelSize += 1
+        while byte != b"":
+            kernelSize += 1
+            byte = f.read(1)
+            dd.append(int.from_bytes(byte, byteorder='little'))
+    return dd
+
+def open_app(fname):
+    dd = []
+
+    with open(fname, "rb") as f:
+        byte = f.read(1)
+        dd.append(int.from_bytes(byte, byteorder='little'))
+        while byte != b"":
+            byte = f.read(1)
+            dd.append(int.from_bytes(byte, byteorder='little'))
+    return dd
+
+def write_file(dd, withPos = 0):
+    with open(copyTo, "rb+") as f:
+        f.seek(withPos, 0)
+        for x in dd:
+            f.write(x.to_bytes(1, 'little', signed=False))
+
+def append(res, plus, offset):
+    for (id,el) in enumerate(plus):
+        res[id+offset] = el
+    return res
+
+def get_from(offset, len):
+    global dd
+    res = 0
+    mt = 1
+    for i in range(len):
+        res += dd[offset + i] * mt
+        mt *= 256
+    return res
+
+dd = open_file()
+
+e_shoff = get_from(0x20, 4)
+e_shentsize = get_from(0x2E, 2)
+e_shnum = get_from(0x30, 2)
+e_shstrndx = get_from(0x32, 2)
+print("Start of the section header table ", e_shoff, e_shentsize, e_shnum, e_shstrndx)
+
+text_size = 0
+data_size = 0
+bss_size = 0
+
+e_shoff_now = e_shoff
+txt_offset = get_from(e_shoff + e_shstrndx * e_shentsize + 0x10, 4)
+for i in range(e_shnum + 1):
+    if i == e_shstrndx:
+        continue
+    name = ""
+    sh_name = get_from(e_shoff_now + 0x00, 4)
+    print(sh_name)
+    while dd[txt_offset+sh_name] != 0:
+        name += chr(dd[txt_offset+sh_name])
+        sh_name+=1
+    sh_type = get_from(e_shoff_now + 0x04, 4)
+    sh_size = get_from(e_shoff_now + 0x14, 4)
+    sh_entsize = get_from(e_shoff_now + 0x24, 4)
+    if name == '.text':
+        text_size += sh_size
+    if name == '.rodata':
+        text_size += sh_size
+    if name == '.eh_frame':
+        text_size += sh_size
+    if name == '.data':
+        data_size += sh_size
+    if name == '.bss':
+        bss_size += sh_size
+    print(name, sh_type, sh_size, sh_entsize)
+    e_shoff_now += e_shentsize
+
+
+print("text: {0}, data: {1}, bss:{2}".format(text_size, data_size, bss_size))
+
+kernelSize = text_size + data_size + bss_size
+kernelSize += 2 # Including offset of size
+kernelSizeKb = (kernelSize + 1024 - 1) // 1024
+kernelSizeKb1 = kernelSizeKb % 256
+kernelSizeKb2 = kernelSizeKb // 256
+print("Kernel Size (KB) ", kernelSizeKb)
+d_kernel = [0, 0]
+d_kernel[0] = kernelSizeKb1
+d_kernel[1] = kernelSizeKb2
+
+d_kernel += dd[0x1000:(0x1000 + text_size)]
+# print_g(d_kernel)
+
+zeroes = [0] * (512 * (format_settings['ReservedSectors'] - 1))
+write_file(zeroes, 512)
+write_file(d_kernel, 512)
+print(kernelSize)

utils/legacy/fat16_formatter.py

@@ -0,0 +1,208 @@
+# implemented in python to support all platforms
+# xOS
+# fat16 in xOS
+
+from config import format_settings
+
+filename = format_settings['filename']
+
+file_descriptor = {
+    'name': filename,
+    'size': 0, #(bytes)
+}
+
+def open_file():
+    size = 0
+    with open(filename, "rb") as f:
+        byte = f.read(1)
+        while byte != b"":
+            size+=1
+            byte = f.read(1)
+
+    file_descriptor['size'] = size
+
+def write_file(dd, withPos = 0):
+    with open(filename, "rb+") as f:
+        f.seek(withPos, 0)
+        f.write(bytes(x for x in dd))
+
+def merge(res, plus, offset):
+    for (id,el) in enumerate(plus):
+        res[id + offset] = el
+    return res
+
+def test_id():
+    result = bytearray(8)
+    textCode = 'xOSToP'
+    for (id,el) in enumerate(textCode):
+        result[id] = ord(el)
+    return result
+
+def bytes_per_sector():
+    result = bytearray(2)
+    result[0] = format_settings['BytesPerSector'] % 256
+    result[1] = format_settings['BytesPerSector'] // 256
+    return result
+
+def sectors_per_cluster():
+    result = bytearray(1)
+    result[0] = format_settings['SectorPerClustor'] % 256
+    return result
+
+def number_of_fats():
+    result = bytearray(1)
+    result[0] = format_settings['NumberOfFATs'] % 256
+    return result
+
+def root_entires():
+    result = bytearray(2)
+    result[0] = format_settings['RootEntires'] % 256
+    result[1] = format_settings['RootEntires'] // 256
+    return result
+
+def load_kernel():
+    result = bytearray(2)
+    result[0] = format_settings['ReservedSectors'] % 256
+    result[1] = format_settings['ReservedSectors'] // 256
+    return result
+
+def reserved_sectors():
+    result = bytearray(2)
+    result[0] = format_settings['ReservedSectors'] % 256
+    result[1] = format_settings['ReservedSectors'] // 256
+    return result
+
+def volume_label():
+    result = bytearray(11)
+    for i in range(11):
+        result[i] = 0x20
+    textCode = format_settings['VolumeName']
+    for (id,el) in enumerate(textCode):
+        result[id] = ord(el)
+    return result
+
+def system_id():
+    result = bytearray(8)
+    for i in range(8):
+        result[i] = 0x20
+    textCode = 'FAT16'
+    for (id,el) in enumerate(textCode):
+        result[id] = ord(el)
+    return result
+
+def header():
+    result = bytearray(512)
+    result = merge(result, test_id(), 0x3)
+    result = merge(result, bytes_per_sector(), 0xB)
+    result = merge(result, sectors_per_cluster(), 0xD)
+    result = merge(result, reserved_sectors(), 0xE)
+    result = merge(result, number_of_fats(), 0x10)
+    result = merge(result, root_entires(), 0x11)
+    result = merge(result, sectors_per_fat(), 0x16)
+    result = merge(result, volume_label(), 0x2B)
+    result = merge(result, system_id(), 0x36)
+    result[511] = 0x00
+    result[510] = 0x00
+    print_g(result)
+    return result
+
+def fat_size():
+    if (format_settings['RootEntires'] * 32) % 512 != 0:
+        print("RootEntires error [couldn't fit into sectors]")
+        exit(0)
+    root_dir_sectors = (format_settings['RootEntires'] * 32) // 512
+    load_sectors = format_settings['ReservedSectors']
+    data_sectors = file_descriptor['size'] // 512 - root_dir_sectors - load_sectors
+    for fat_sectors in range(1, 256):
+        free_data_sectors = data_sectors - fat_sectors * format_settings['NumberOfFATs']
+        covered_data_sectors = fat_sectors * 512 // 2 - 2
+        print(free_data_sectors, covered_data_sectors)
+        if free_data_sectors <= format_settings['SectorPerClustor'] * covered_data_sectors:
+            return fat_sectors
+    return 256
+
+def sectors_per_fat():
+    fsize = fat_size()
+    result = bytearray(2)
+    result[0] = fsize % 256
+    result[1] = fsize // 256
+    return result
+
+def fat():
+    fsize = fat_size()
+    print(fsize)
+    result = bytearray(512 * fsize)
+    result[0] = 0xf8
+    result[1] = 0xff
+    result[2] = 0xff
+    result[3] = 0xff
+    root_dir_sectors = (format_settings['RootEntires'] * 32) // 512
+    load_sectors = format_settings['ReservedSectors']
+    data_sectors = file_descriptor['size'] // 512 - root_dir_sectors - load_sectors
+    free_data_sectors = data_sectors - fsize * format_settings['NumberOfFATs']
+    covered_data_clusters = fsize * 512 // 2 - 2
+    data_clusters = (free_data_sectors - format_settings['SectorPerClustor'] + 1) // format_settings['SectorPerClustor'] + 1
+    unused_clusters = covered_data_clusters - data_clusters
+    print(covered_data_clusters, data_clusters, unused_clusters)
+    if unused_clusters < 0:
+        print("Error with clusters")
+        exit(0)
+    for i in range(unused_clusters):
+        result[512 * fsize - 2 * unused_clusters + 2 * i] = 0xff
+        result[512 * fsize - 2 * unused_clusters + 2 * i + 1] = 0xff
+
+    print_g(result)
+    return result
+
+def root_dir():
+    result = bytearray(format_settings['RootEntires'] * 32)
+    return result
+
+def print_gh(el):
+    if (el >= 10):
+        return chr(el - 10 + ord('A'))
+    return chr(el + ord('0'))
+
+def print_g(result):
+    for (id,el) in enumerate(result):
+        if id % 16 == 0:
+            print()
+        print(print_gh(el//16), end="")
+        print(print_gh(el%16), end=" ")
+
+
+if __name__ == "__main__":
+    print("xOS Formatter")
+    print("To change setting change config file")
+    open_file()
+
+    pos = 0
+
+    print("writing header")
+    print("Header starts at ", pos)
+    # writing header
+    header_e = header()
+    write_file(header_e, pos)
+    pos += format_settings['ReservedSectors'] * 512
+    print("Kernel starts at ", 512)
+
+    print("writing fats")
+    print("Fats start at ", pos)
+    # writing fats
+    fat_e = fat()
+    for i in range(format_settings['NumberOfFATs']):
+        write_file(fat_e, pos)
+        pos += len(fat_e)
+
+    print("writing root_dir")
+    print("Root dir starts at ", pos)
+    # writing root_dir
+    root_dir_e = root_dir()
+    write_file(root_dir_e, pos)
+    pos += len(root_dir_e)
+
+    write_file(bytearray(file_descriptor['size'] - pos), pos)
+
+    print("Data starts at ", pos)
+    print("Data size is ", file_descriptor['size'] - pos)
+    print("Data size is (Mb)", (file_descriptor['size'] - pos) / (1024 * 1024))

utils/legacy/install_apps.py

@@ -0,0 +1,33 @@
+import os
+
+ignore = [
+    '.DS_Store'
+]
+
+apps_dir = 'home'
+apps_dir_full = os.getcwd() + '/' + apps_dir
+apps_dir_len = len(apps_dir)
+installer = './utils/app_installer.exec'
+print(apps_dir)
+
+folders = []
+files = []
+
+# r = root, d = directories, f = files
+for r, d, f in os.walk(apps_dir):
+    for folder in d:
+        folders.append((r[apps_dir_len:]+'/', folder))
+    for file in f:
+        files.append((r[apps_dir_len:]+'/', file))
+
+for path, fname in folders:
+    cmd = "{0} mkdir {1} {2}".format(installer, path, fname)
+    print(cmd)
+    os.system(cmd)
+
+for path, fname in files:
+    print (apps_dir+'/'+fname)
+    cmd = "{0} writefile {1} {2} {3}".format(installer, path, fname, apps_dir+'/'+fname)
+    if not (fname in ignore):
+        print(cmd)
+        os.system(cmd)

utils/legacy/interrgen.py

@@ -0,0 +1,38 @@
+for i in range(32):
+    print("""
+isr{0}:
+    cli
+    pusha
+    push ds
+    push es
+    push fs
+    push gs
+    push esp
+    push byte {0}
+    jmp  isr_common_bottom
+    """.format(i)
+)
+
+
+for i in range(32, 40):
+    print("""
+irq{0}:
+    cli
+    pusha
+    push ds
+    push es
+    push fs
+    push gs
+    push esp
+    push byte {1}
+    jmp  irq_master_common_bottom
+    """.format(i-32, i)
+)
+
+
+for i in range(40, 48):
+    print("""
+syscall{0}:
+    
+    """.format(i-32, i)
+)