Add more minix

Author: drunkbatya

software/scripts/minixfs/bitmap.py

@@ -1,24 +1,62 @@
+from dataclasses import dataclass
+
+
+@dataclass
 class BitMap:
-    def __init__(self, bits_count: int, need_size: int):
+    data: list[int]
+
+    @classmethod
+    def create(cls, bits_count: int, need_size: int) -> "BitMap":
         bits_in_byte = 8
 
         need_bytes = bits_count // bits_in_byte
-        data = (b"\x00" * need_bytes)
+        data = [0x00] * need_bytes
 
         need_bytes_rem = bits_count % bits_in_byte
         if need_bytes_rem:
-            data += (0xFF << need_bytes_rem) & 0xFF
+            data += [(0xFF << need_bytes_rem) & 0xFF]
             need_bytes += 1
 
-        if need_bytes > need_size:
-            raise Exception(f'Need more bytes to create bitmap then size requested')
+        assert need_bytes <= need_size
 
         add_bytes = need_size - need_bytes
-        data += (b"\xFF" * add_bytes)
+        if add_bytes != 0:
+            data += [0xFF] * add_bytes
 
         assert len(data) == need_size
 
-        self.data = data
+        return cls(data=data)
 
-    def get_bytes(self) -> bytes:
+    def get_data(self) -> list[int]:
         return self.data
+
+    def get_free_bit(self) -> int | None:
+        bits_in_byte = 8
+
+        assert len(self.data) != 0
+
+        for cur_byte_idx, cur_byte in enumerate(self.data):
+            if cur_byte != 0xFF:
+                for n_bit in range(0, bits_in_byte):
+                    if (cur_byte & (0x01 << n_bit)) == 0:
+                        return n_bit + (bits_in_byte * cur_byte_idx)
+
+        return None
+
+    def aquire_bit(self, num: int):
+        bits_in_byte = 8
+        byte_pos = num // bits_in_byte
+        bit_pos = num % bits_in_byte
+
+        self.data[byte_pos] |= 0x01 << bit_pos
+
+    def release_bit(self, num: int):
+        bits_in_byte = 8
+        byte_pos = num // bits_in_byte
+        bit_pos = num % bits_in_byte
+
+        self.data[byte_pos] &= ~(0x01 << bit_pos)
+
+    @classmethod
+    def load(cls, data: list[int]) -> "BitMap":
+        return cls(data=data)

software/scripts/minixfs/dirent.py

@@ -0,0 +1,40 @@
+import struct
+from dataclasses import dataclass
+from enum import IntEnum, IntFlag
+
+# B = uint8, H = uint16, L = uint32
+D_STRUCT = struct.Struct(
+    "<"  # little-endian
+    "H"  # inode
+    "30B"  # name
+)
+
+NAME_SIZE = 30
+TOTAL_SIZE = 32
+
+
+@dataclass
+class Dirent:
+    inode: int
+    name: list[int]
+
+    def pack(self) -> bytes:
+        assert isinstance(self.name, list)
+        assert len(self.name) <= NAME_SIZE
+
+        raw = D_STRUCT.pack(
+            self.inode,
+            *self.name,
+        )
+
+        assert len(raw) == TOTAL_SIZE
+
+        return raw
+
+    @classmethod
+    def load(cls, data: list[int]) -> "Dirent":
+        buf = bytes(data)
+        assert len(buf) == TOTAL_SIZE
+
+        fields = D_STRUCT.unpack_from(buf, 0)
+        return cls(*fields)

software/scripts/minixfs/inode.py

@@ -0,0 +1,66 @@
+import struct
+from dataclasses import dataclass
+from enum import IntEnum, IntFlag
+
+
+class FileType(IntEnum):
+    S_IFSOCK = 0xC000
+    S_IFLNK = 0xA000
+    S_IFREG = 0x8000
+    S_IFBLK = 0x6000
+    S_IFDIR = 0x4000
+    S_IFCHR = 0x2000
+    S_IFIFO = 0x1000
+
+
+# B = uint8, H = uint16, L = uint32
+I_STRUCT = struct.Struct(
+    "<"  # little-endian
+    "H"  # i_mode
+    "H"  # i_uid
+    "L"  # i_size
+    "L"  # i_time
+    "B"  # i_gid
+    "B"  # i_nlinks
+    "9H"  # i_zone
+)
+
+I_ZONE_COUNT: int = 9
+TOTAL_SIZE: int = 32
+
+
+@dataclass
+class Inode:
+    i_mode: int
+    i_uid: int
+    i_size: int
+    i_time: int
+    i_gid: int
+    i_nlinks: int
+    i_zone: list[int]
+
+    def pack(self) -> list[int]:
+        assert isinstance(self.i_zone, list)
+        assert len(self.i_zone) == I_ZONE_COUNT
+
+        raw = I_STRUCT.pack(
+            self.i_mode,
+            self.i_uid,
+            self.i_size,
+            self.i_time,
+            self.i_gid,
+            self.i_nlinks,
+            *self.i_zone,
+        )
+
+        assert len(raw) == TOTAL_SIZE
+
+        return list(raw)
+
+    @classmethod
+    def load(cls, data: list[int]) -> "Inode":
+        buf = bytes(data)
+        assert len(buf) == TOTAL_SIZE
+
+        fields = I_STRUCT.unpack_from(buf, 0)
+        return cls(*fields)

software/scripts/minixfs/minixfs.py

@@ -6,7 +6,9 @@
 # Zonesize=1024
 # Maxsize=268966912
 
-from . import superblock, bitmap
+from . import superblock, bitmap, inode
+
+from pathlib import Path
 
 
 class MinixFS:
@@ -22,6 +24,13 @@ def __init__(self, dev: BlockDevice):
         self.imap_offset = self.superblock_offset + self.superblock_size
         self.inode_size = 32
 
+    def store_superblock(self, sb: superblock.SuperBlock):
+        sb_bytes = list(sb.pack())
+
+        superblock_offset_lba = self.superblock_offset // self.phys_block_size
+        superblock_size_lba = self.superblock_size // self.phys_block_size
+        self.dev.write(superblock_offset_lba, sb_bytes, superblock_size_lba)
+
     def create_superblock(self):
         sb = superblock.SuperBlock(
             s_ninodes=352,
@@ -34,13 +43,7 @@ def create_superblock(self):
             s_magic=superblock.SB_MAGIC_LONG_FN,
             s_state=0,
         )
-
-        sb_bytes = list(sb.pack())
-
-        superblock_offset_lba = self.superblock_offset // self.phys_block_size
-        superblock_size_lba = self.superblock_size // self.phys_block_size
-        self.dev.write(superblock_offset_lba, sb_bytes, superblock_size_lba)
-
+        self.store_superblock(sb)
 
     def parse_superblock(self):
         superblock_offset_lba = self.superblock_offset // self.phys_block_size
@@ -54,25 +57,102 @@ def parse_superblock(self):
         self.zmap_size = self.sb.s_zmap_blocks * self.block_size
         self.inodes_offset = self.zmap_offset + self.zmap_size
 
-    def create_inode_bitmap(self):
-        bm = bitmap.BitMap(self.sb.s_ninodes, self.sb.s_imap_blocks * self.block_size)
-        bm_bytes = list(bm.get_bytes())
+    def store_inode_bitmap(self, bm: bitmap.BitMap):
+        bm_bytes = bm.get_data()
         inode_bitmap_offset_lba = self.imap_offset // self.phys_block_size
-        inode_bitmap_size_lba = (self.sb.s_imap_blocks * self.block_size) // self.phys_block_size
+        inode_bitmap_size_lba = (
+            self.sb.s_imap_blocks * self.block_size
+        ) // self.phys_block_size
         self.dev.write(inode_bitmap_offset_lba, bm_bytes, inode_bitmap_size_lba)
 
-    def create_znode_bitmap(self):
-        bm = bitmap.BitMap(self.sb.s_nzones, self.sb.s_zmap_blocks * self.block_size)
-        bm_bytes = list(bm.get_bytes())
+    def create_inode_bitmap(self):
+        bm = bitmap.BitMap.create(
+            self.sb.s_ninodes, self.sb.s_imap_blocks * self.block_size
+        )
+        self.store_inode_bitmap(bm)
+
+    def parse_inode_bitmap(self):
+        inode_bitmap_offset_lba = self.imap_offset // self.phys_block_size
+        inode_bitmap_size_lba = (
+            self.sb.s_imap_blocks * self.block_size
+        ) // self.phys_block_size
+        data = self.dev.read(inode_bitmap_offset_lba, inode_bitmap_size_lba)
+
+        self.inode_bitmap = bitmap.BitMap.load(data)
+
+    def store_znode_bitmap(self, bm: bitmap.BitMap):
+        bm_bytes = bm.get_data()
         znode_bitmap_offset_lba = self.zmap_offset // self.phys_block_size
-        znode_bitmap_size_lba = (self.sb.s_zmap_blocks * self.block_size) // self.phys_block_size
+        znode_bitmap_size_lba = (
+            self.sb.s_zmap_blocks * self.block_size
+        ) // self.phys_block_size
         self.dev.write(znode_bitmap_offset_lba, bm_bytes, znode_bitmap_size_lba)
 
+    def create_znode_bitmap(self):
+        bm = bitmap.BitMap.create(
+            self.sb.s_nzones, self.sb.s_zmap_blocks * self.block_size
+        )
+        self.store_znode_bitmap(bm)
+
+    def parse_znode_bitmap(self):
+        znode_bitmap_offset_lba = self.zmap_offset // self.phys_block_size
+        znode_bitmap_size_lba = (
+            self.sb.s_zmap_blocks * self.block_size
+        ) // self.phys_block_size
+        data = self.dev.read(znode_bitmap_offset_lba, znode_bitmap_size_lba)
+
+        self.znode_bitmap = bitmap.BitMap.load(data)
+
+    def store_inode(self, i: inode.Inode, pos: int):
+        # calc block no and LBA addr where inode located
+        inode_size_lba = 1
+        inode_offset = self.inodes_offset + (pos * self.inode_size)
+        inode_offset_lba = inode_offset // self.phys_block_size
+        inode_offset_rem = inode_offset % self.phys_block_size
+
+        # read full disk block
+        data = self.dev.read(inode_offset_lba, inode_size_lba)
+
+        # read, modify, write
+        i_raw = i.pack()
+        data[inode_offset_rem : inode_offset_rem + len(i_raw)] = i_raw
+
+        # storing byte back
+        self.dev.write(inode_offset_lba, data, inode_size_lba)
+
+    def create_inode(self):
+        free_inode_num = self.inode_bitmap.get_free_bit()
+        self.inode_bitmap.aquire_bit(free_inode_num)
+        self.store_inode_bitmap(self.inode_bitmap)
+
+        free_znode_num = self.znode_bitmap.get_free_bit()
+        self.znode_bitmap.aquire_bit(free_znode_num)
+        self.store_znode_bitmap(self.znode_bitmap)
+
+        i = inode.Inode(
+            i_mode=int(inode.FileType.S_IFDIR) | 0o755,
+            i_uid=0,
+            i_size=64,
+            i_time=0x699F6471,
+            i_gid=0,
+            i_nlinks=2,
+            i_zone=[free_znode_num] + [0 for i in range(0, 8)],
+        )
+        self.store_inode(i, free_inode_num)
+
+    def create_directory(self, path: Path):
+        self.create_inode()
+
     def create(self):
         self.create_superblock()
         self.parse_superblock()
         self.create_inode_bitmap()
+        self.parse_inode_bitmap()
         self.create_znode_bitmap()
+        self.parse_znode_bitmap()
+        self.create_directory(Path("."))
+        # self.create_directory(Path(".."))
+        # self.create_inode()
 
     def mount(self):
         # self.cf.write(0, [0x1, 0x02, 0x03], 3)

software/scripts/minixfs/superblock.py

@@ -17,6 +17,8 @@
     "H"  # s_state
 )
 
+TOTAL_SIZE: int = 1024
+
 
 @dataclass
 class SuperBlock:
@@ -30,8 +32,7 @@ class SuperBlock:
     s_magic: int
     s_state: int
 
-    def pack(self) -> bytes:
-        total_size = 1024
+    def pack(self) -> list[int]:
         raw = SB_STRUCT.pack(
             self.s_ninodes,
             self.s_nzones,
@@ -43,10 +44,12 @@ def pack(self) -> bytes:
             self.s_magic,
             self.s_state,
         )
-        return raw + b"\x00" * (total_size - len(raw))
+        return list(raw) + [0x00] * (TOTAL_SIZE - len(raw))
 
     @classmethod
     def load(cls, data: list[int]) -> "SuperBlock":
         buf = bytes(data)
+        assert len(buf) == TOTAL_SIZE
+
         fields = SB_STRUCT.unpack_from(buf, 0)
         return cls(*fields)