Gitingest

Include files under: 50kB

Private Repository NEW

Summary

Repository: jobala/tinyfs
Files analyzed: 24

Estimated tokens: 8.4k

Download

Directory Structure

Directory structure:

└── jobala-tinyfs/

    ├── README.md

    ├── Cargo.toml

    ├── CHANGELOG.md

    ├── LICENSE

    ├── Makefile

    ├── .rustfmt.toml

    ├── design/

    │   ├── fs_init.md

    │   ├── ls.md

    │   ├── mkdir.md

    │   ├── mkfs.md

    │   ├── stat.md

    │   └── tinyfs.md

    ├── src/

    │   ├── main.rs

    │   ├── mkfs.rs

    │   └── tiny/

    │       ├── bitmap.rs

    │       ├── constants.rs

    │       ├── directory.rs

    │       ├── fs.rs

    │       ├── fs_extensions.rs

    │       ├── inode.rs

    │       ├── mod.rs

    │       └── superblock.rs

    └── .github/

        ├── pull_request_template.md

        └── workflows/

            └── release-please.yml

Files Content

================================================
FILE: README.md
================================================
## TinyFS: A Little File System

TinyFS is a little filesystem with no big plans.

## Setup

1. Run `mkdir /tmp/tiny`
2. Run `sudo addgroup <username> fuse`

## Running

1. To start **tinyFS** run `make run` in this project's root dir
2. To interact with tinyFS, open another terminal and perform file operations on `/tmp/tiny` ie `stat /tmp/tiny`

## Resources

- [Filesystem Implementation](https://pages.cs.wisc.edu/~remzi/OSTEP/file-implementation.pdf)
- [To FUSE or Not To Fuse](https://libfuse.github.io/doxygen/fast17-vangoor.pdf)
- [Fuse Filesystems](https://zsiciarz.github.io/24daysofrust/book/vol1/day15.html)

## Supported

- [x] stat
- [x] ls
- [x] mkdir
- [ ] rmdir
- [ ] create
- [ ] read
- [ ] write
- [ ] unlink



================================================
FILE: Cargo.toml
================================================
[package]
name = "tinyFS"
version = "0.1.0"
edition = "2021"

[dependencies]
fuser = "0.15.1"
bincode = "1.3.3"
bitvec = "1"
serde = { version = "1", features = ["derive"] }
libc = "0.2.169"



================================================
FILE: CHANGELOG.md
================================================
# Changelog

## [0.2.0](https://github.com/jobala/tinyFS/compare/v0.1.0...v0.2.0) (2025-01-22)


### Features

* add support for ls ([300407c](https://github.com/jobala/tinyFS/commit/300407c5af3d0937031a41fa173658f74bb5b141))
* support mkdir ([#10](https://github.com/jobala/tinyFS/issues/10)) ([6caeb48](https://github.com/jobala/tinyFS/commit/6caeb48b0142733423bfa9d864421309a32e1436))
* support start ([a43bd6c](https://github.com/jobala/tinyFS/commit/a43bd6ccec0e0619e49c18b2fcedb05f1fc04586))


### Bug Fixes

* add instructions ([3831f9a](https://github.com/jobala/tinyFS/commit/3831f9a40795f18c6316bde46fc28077fe9a6667))
* refactor ttl ([4444642](https://github.com/jobala/tinyFS/commit/4444642e65f0bfbff47255c9f3fcf7d68239a777))

## [0.1.0](https://github.com/jobala/tinyFS/compare/v0.0.1...v0.1.0) (2025-01-11)


### Features

* create root directory on first mount ([b015914](https://github.com/jobala/tinyFS/commit/b01591444d23decd8214538e356f9255caa991a0))

## [0.0.1](https://github.com/jobala/tinyFS/compare/0.0.0...v0.0.1) (2025-01-04)


### Bug Fixes

* invalid workflow file ([025c950](https://github.com/jobala/tinyFS/commit/025c950ec4b2da0c98e66f7f8b56bc96cc35e8f8))
* test release please ([2f1845f](https://github.com/jobala/tinyFS/commit/2f1845fb5ac9f520b0b216307b03c64d83bc7630))



================================================
FILE: LICENSE
================================================
MIT License

Copyright (c) 2024 Japheth Obala

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.



================================================
FILE: Makefile
================================================
run:
	- sudo fusermount -u /tmp/tiny > /dev/null 2>&1
	cargo run



================================================
FILE: .rustfmt.toml
================================================
max_width=120



================================================
FILE: design/fs_init.md
================================================
## Filesystem Initialization

Filesystem initialisation happens whenever the file system is mounted.

## Goals

- Create the filesystem's root directory the first time the filesystem is mounted

## Non Goals

- Adding default files in the default directory
- Using A BTree to store directory entries

## Design

The root directory should be created only if it wasn't created before. We will use the inode bitmap table to track what
inode blocks have been used/allocated and since the root directory's inode is the first to be created we should
check whether the inode bitmap at index zero is allocated. If it is, return.

```rust
if bitmap.is_inode_allocated(0) {
    return
}

...
```

Both files and directories are represented by an Inode, for directories, the Inode's **file_type** attribute is
set to directory.

```rust
let inode = Inode::new()
inode.file_type = 1 // 1 == directory
```

Directories have entries which could be files or other directories, we'll use a hashmap that maps a path to some
file or directory inode number.

```rust
struct DirData {
    entries HashMap<string, i32>
}
```

Each inode tracks where in disk its data is written. The method `allocate_blocks` returns the write location
addresses, which are then stored in the inode's **block_ptrs** property.

```rust
let dir_data = DirData::default()
inode.block_ptrs = self.allocate_blocks(dir_data)
```

Finally, we need to save the inode to disk at the first inode block(zero indexed) and make sure the inode bitmap
at index zero is marked as allocated.

```rust
inode.save_at(0, &disk)
bitmap.allocate_inode(0)
```



================================================
FILE: design/ls.md
================================================
## ls

## Goals

## Non-Goals

## Design



================================================
FILE: design/mkdir.md
================================================
## Support mkdir

The `mkdir` command is used to create directories.

## Goals

- Support mkdir

## Non-Goals

## Design

Directory creation is handled by the `mkdir` FUSE function. The method signature specifies the **parent** directory, the
directory **name** and **mode** -- permissions.

```rust
  fn mkdir(&mut self, _req: &fuse::Request, parent: u64, name: &std::ffi::OsStr, mode: u32, reply: fuse::ReplyEntry)
```

1. Load the parent inode from disk
2. Load the parent's dir data
3. Create a new Inode for the new directory
4. Update the parent's dir data with a new entry based on the new Inode's data



================================================
FILE: design/mkfs.md
================================================
## mkfs

TinyFS uses a file as a disk, `mkfs` formats this file and lays out the different parts like the superblock,
bitmap so and so forth.

## Goals
    - Format disk with Superblock
    - Format disk with Bitmap table

## Non Goals
    - mkfs doesn't intend to format disk with an inode table
    - mkfs doesn't intend to format disk with a data blocks table

Formatting the disk requires to first have the data structure in memory, for example TinyFS' data blocks table
is 56 blocks wide -- that is 56 * 4kb in size -- which will be wasteful to load into memory then write to disk.
So how do we know a blocks location then? Simple, we can calculate it based on the bitmap index and the data
block's table starting address.

For example, the location of block 35 is;

block_loc = data_table_start + (35 * sizeof(block))

We can then read and write to that location without loading the whole datablock table -- about 224mb -- into memory.

## Design

**mkfs** takes some path which is where it will create its disk.

### Superblock

The superblock holds metadata about the filesystem and knows how to serialize and deserialize itself into a binary format
which `mkfs` then writes to disk.

### Bitmaps

Bitmaps are used to determine whether an inode or block is free or allocated. TinyFS has two bitmap tables; inode and 
block bitmaps. However, for TinyFS we have more bits than we can use because each bitmap table uses a block (each block
is 4096 bytes) giving us 4096 * 8 -- 32k-- bits. In reality, TinyFS needs around 80 bits for inodes.

Bit 0 in the bitmap corresponds to inode 0, Bit 1 to inode 1 so and so forth. Bitmap also knows how to serialize and 
deserialize itself to a binary format which `mkfs` uses to write to disk.

## Implementation

```
class Superblock:
    function serialize_into()
    function deserialize_from()

class Bitmap:
    function serialize_into()
    function deserialize_from()

function mkfs(path: string)
    file = open(path, create)

    sb = Superblock()
    sb.serialize_into(file)

    bm = Bitmap()
    bm.serialize_into(file)

    file.flush()
```



================================================
FILE: design/stat.md
================================================
## stat 

`stat` is a linux command for showing file information and its sample output is shown below.

```
File: .
Size: 4096            Blocks: 8          IO Block: 4096   directory
Device: 179,2   Inode: 1278537     Links: 7
Access: (0775/drwxrwxr-x)  Uid: ( 1000/  jobala)   Gid: ( 1003/  jobala)
Access: 2025-01-14 16:05:26.789054116 +0300
Modify: 2025-01-14 16:05:26.463056875 +0300
Change: 2025-01-14 16:05:26.463056875 +0300
Birth: 2024-12-14 15:22:49.207461152 +0300
```

## Goals

- Support `stat` for root directory

## Non Goals

- Supporting `lookup`for non-root directories

## Design

For tinyFS to support `stat` it needs to implement two methods `getattr` & `lookup` their signatures are shown below.

```rust
 lookup(&mut self, _req: &fuse::Request, _parent: u64, _name: &std::ffi::OsStr, reply: fuse::ReplyEntry);

 getattr(&mut self, _req: &fuse::Request, ino: u64, reply: fuse::ReplyAttr);
```

### Lookup

`lookup` finds an inode given the parent's inode number and the name of the file/directory. 

#### Steps

1. Check if parent is 1
    1. If it is, 
        - load the root inode from disk
        - convert the inode to `FileAttr`
        - send a FUSE reply with the `FileAttr` object
    2. If not,
        - send a FUSE error reply with `libc::ENOENT`
    

### getattr

`getattr` has `ino` as one of its params, it holds the inode number. `lookup` provides `getattr` the inode number which
getattr uses to load an inode from disk.

#### Steps

1. Read inode from disk
2. Convert `Inode` to a `FileAttr` object
3. Send a FUSE reply with the  `FileAttr` object 
``



================================================
FILE: design/tinyfs.md
================================================

## TinyFS
TinyFS is a small and simple FUSE based filesystem created mainly for educational purposes and has no ambition of
becoming a production ready filesystem. TinyFS will be implemented in Rust.

### Goals
- Support **mkfs** to create the disk layout
- Support the following file operations
  - **open** filename flag
  - **read** fd size
  - **write** fd string
  - **seek** fd offset
  - **close** fd
  - **mkdir** dirname
  - **rmdir** dirname
  - **cd** dirname
  - **ls**
  - **cat**
  - **tree**



### Non Goals
- Support Journaling
- Supporting very large files
- Caching
- Becoming a distributed filesystem


## Design

### Disk Layout

TinyFS formats the disk into 4kb  blocks and will have 64 blocks in total, which means that TinyFS requires a disk with
256mb free space. The first block will be used for the superblock, the next two blocks will be used for inode and data
bitmap tables respectively and the following 5 blocks are used for inodes.

<figure align="center">

![Disk](img/disk.png)
<figcaption >TinyFS Disk Layout</figcaption>
</figure>

The disk layout above means that the first 8 blocks are used for managing the filesystem and the remaining 56 blocks are
used for actual data storage.

### Datastructures

#### Superblock

Superblock contains metadata about the filesystem. TinyFS reads the superblock on initialization to know things like
how much disk space is remaing.

```
Superblock
  block_size int
  block_count int
```

#### Bitmaps

A bitmap is an array of bytes used to indicate whether the corresponding block is free or allocated. Each bit in the array
maps to a corresponding block. Bit 0 maps to block 0, bit 1 maps to block 1 so on and so forth.

```
  Bitmap
   []byte
```

#### Inodes

Inodes hold file metadata and represent both files and directories

```
  Inode
    mode int
    size int
    created_at Time
    modified_at Time
    deleted_at Time
    flags byte
    hard_links int
    direct_blocks []int
    indirect_block []int
    double_indirect_block []int
```


#### Data Blocks

Datablocks have no particular structure and hold the actual file data.

## Implementation

[mkfs](./mkfs.md)
[creating a file](./creating_a_file.md)

## Notes
Before mounting the FS, make sure that the directory exists ie `mkdir /tmp/tiny`

To unmount the fs, `fusermount -u /tmp/tiny`

When permissions are denied use `sudo addgroup <USERNAME> fuse`

## References

[Filesystem Implementation](https://pages.cs.wisc.edu/~remzi/OSTEP/file-implementation.pdf)



================================================
FILE: src/main.rs
================================================
mod mkfs;
mod tiny;

use std::{fs::OpenOptions, path::Path};

use tiny::{constants::Disk, TinyFS};

fn main() {
    let path = Path::new("./tiny.img");
    if !path.exists() {
        mkfs::make("./tiny.img");
    }

    let mount_path = "/tmp/tiny";

    fuser::mount2(TinyFS { disk: load_disk(path) }, &mount_path, &[]).expect("expected filesytem to mount");
}

fn load_disk(path: &Path) -> Disk {
    OpenOptions::new()
        .write(true)
        .read(true)
        .open(path)
        .expect("file to have been opened")
}



================================================
FILE: src/mkfs.rs
================================================
use std::{
    fs::OpenOptions,
    io::{BufWriter, Write},
};

use crate::tiny::{bitmap::Bitmap, constants::BLOCK_SIZE, superblock::Superblock};

pub fn make(path: &str) {
    let disk = OpenOptions::new()
        .write(true)
        .create(true)
        .open(path)
        .expect("file to have been opened");

    let mut buf = BufWriter::new(&disk);

    let mut super_block = Superblock::new(BLOCK_SIZE, 64);
    super_block
        .serialize_into(&mut buf)
        .expect("superblock to have been serialized");

    let mut bitmap = Bitmap::new();
    bitmap.save_to(&disk).expect("bitmap to have been serialized");

    buf.flush().expect("buffer to have been flushed");
    disk.set_len(64 * BLOCK_SIZE as u64).expect("to have set file size");
}



================================================
FILE: src/tiny/bitmap.rs
================================================
use std::io::{self, BufReader, BufWriter, Read, Seek, SeekFrom, Write};

use bitvec::prelude::*;

use super::constants::{Disk, BLOCK_SIZE, DATA_BLOCK_BASE};

impl Bitmap {
    pub fn new() -> Self {
        Bitmap {
            inode: bitvec![u8, Lsb0; 0; BLOCK_SIZE * 8],
            data: bitvec![u8, Lsb0; 0; BLOCK_SIZE * 8 ],
        }
    }

    pub fn from(disk: &Disk) -> Bitmap {
        let buf = BufReader::new(disk);
        Self::deserialize_from(buf).expect("failed to load bitmap")
    }

    // TODO: check against the maximum number of inodes
    pub fn find_free_inode(&mut self) -> usize {
        // we start searching from 1 instead of 0 because
        // root inode has index 1.
        for i in 1..self.inode.len() {
            if self.inode[i] == false {
                return i;
            }
        }

        return 0;
    }

    pub fn allocate_inode(&mut self, index: usize, disk: &Disk) {
        self.inode.set(index, true);
        self.save_to(disk).expect("error saving inode to disk")
    }

    //pub fn free_inode(&mut self, index: usize) {
    //    self.inode.set(index, false);
    //}

    pub fn allocate_data_block(&mut self, index: usize, disk: &Disk) {
        self.data.set(index, true);
        self.save_to(disk).expect("error saving inode to disk");
    }

    // TODO: check against the maximum number of blocks
    // TODO: use correct error handling
    // https://doc.rust-lang.org/rust-by-example/error/multiple_error_types/define_error_type.html
    pub fn find_free_data_block(&mut self) -> usize {
        for i in 0..self.data.len() {
            if self.data[i] == false {
                return i;
            }
        }

        return 0;
    }

    pub fn free_data_block(&mut self, block_ptr: u64, disk: &Disk) {
        let index = (block_ptr.wrapping_sub(DATA_BLOCK_BASE)) / BLOCK_SIZE as u64;
        println!("block index: {} ptr: {}", index, block_ptr);

        self.data.set(index as usize, false);
        self.save_to(disk).expect("error saving inode to disk");
    }

    pub fn is_inode_allocated(&mut self, index: usize) -> bool {
        self.inode[index]
    }

    pub fn save_to(&mut self, disk: &Disk) -> Result<(), io::Error> {
        let buf = BufWriter::new(disk);
        self.serialize_into(buf)
    }

    fn serialize_into<W: Write + Seek>(&mut self, mut buf: W) -> Result<(), io::Error> {
        let offset = BLOCK_SIZE as u64;

        buf.seek(SeekFrom::Start(offset))?;
        buf.write_all(self.inode.as_raw_slice())?;
        buf.write_all(self.data.as_raw_slice())?;
        buf.flush()?;
        Ok(())
    }

    fn deserialize_from<R: Read + Seek>(mut r: R) -> Result<Bitmap, io::Error> {
        let offset = BLOCK_SIZE as u64;
        let mut bitmap = Bitmap::new();

        let mut buf = [0u8; BLOCK_SIZE];
        r.seek(SeekFrom::Start(offset))?;
        r.read_exact(&mut buf)?;
        bitmap.inode = BitVec::from_slice(&buf);

        r.read_exact(&mut buf)?;
        bitmap.data = BitVec::from_slice(&buf);

        Ok(bitmap)
    }
}

pub struct Bitmap {
    inode: BitVec<u8>,
    data: BitVec<u8>,
}



================================================
FILE: src/tiny/constants.rs
================================================
use serde::{Deserialize, Serialize};
use std::fs::File;

pub const BLOCK_SIZE: usize = 4096;
pub const INODE_BLOCK_COUNT: u64 = 5u64;
pub const INODE_BLOCK_BASE: u64 = 3u64 * BLOCK_SIZE as u64;
pub const DATA_BLOCK_BASE: u64 = INODE_BLOCK_BASE + (INODE_BLOCK_COUNT * BLOCK_SIZE as u64);

#[derive(Deserialize, Serialize, Clone, Copy, Debug, PartialEq, Default)]
pub enum InodeKind {
    #[default]
    File,
    Dir,
}

pub type Disk = File;
pub type Block = [u8; BLOCK_SIZE];



================================================
FILE: src/tiny/directory.rs
================================================
use std::{
    collections::HashMap,
    io::{Read, Write},
};

use serde::{Deserialize, Serialize};

use super::constants::InodeKind;

impl DirData {
    pub fn serialize_into<W: Write>(&mut self, buf: W) -> Result<(), bincode::Error> {
        bincode::serialize_into(buf, self)
    }

    pub fn deserialize_from<R: Read>(buf: R) -> Result<DirData, bincode::Error> {
        let directory: Self = bincode::deserialize_from(buf)?;
        Ok(directory)
    }

    pub fn insert(&mut self, path: &str, entry: DirEntry) {
        self.entries.insert(String::from(path), entry);
    }
}

#[derive(Serialize, Deserialize, Default, Debug)]
pub struct DirData {
    pub entries: HashMap<String, DirEntry>,
}

#[derive(Serialize, Deserialize, Default, Debug)]
pub struct DirEntry {
    pub ino: u64,
    pub name: String,
    pub kind: InodeKind,
}



================================================
FILE: src/tiny/fs.rs
================================================
use fuser::{FileType, Filesystem};
use std::ffi::c_int;

use crate::tiny::directory::DirEntry;

use super::{
    bitmap::Bitmap,
    constants::{Disk, InodeKind},
    directory::DirData,
    inode::Inode,
};

impl Filesystem for TinyFS {
    fn init(&mut self, _req: &fuser::Request<'_>, _config: &mut fuser::KernelConfig) -> Result<(), c_int> {
        println!("calling init");

        let mut bm = Bitmap::from(&self.disk);
        if bm.is_inode_allocated(1) {
            return Ok(());
        }

        let mut root_inode = Inode::new(InodeKind::Dir);
        root_inode.ino = 1;

        let dir_data = DirData::default();
        root_inode.save_dir_data(dir_data, &mut bm, &self.disk);

        root_inode.save(&self.disk).expect("error saving root directory inode");
        bm.allocate_inode(1, &self.disk);
        Ok(())
    }

    fn lookup(&mut self, _req: &fuser::Request, parent: u64, name: &std::ffi::OsStr, reply: fuser::ReplyEntry) {
        let mut inode = Inode::load_from(&self.disk, parent).expect("error loading inode");
        let parent_dir_data = inode.get_dir_data(&self.disk);

        if let Some(child_entry) = parent_dir_data.entries.get(self.to_string(name)) {
            let mut child = Inode::load_from(&self.disk, child_entry.ino).expect("error loading child");
            reply.entry(&self.ttl(), &child.to_file_attr(), 0);
        } else if parent == 1 && name == "." {
            reply.entry(&self.ttl(), &inode.to_file_attr(), 0);
        } else {
            reply.error(libc::ENOENT);
        }
    }

    fn getattr(&mut self, _req: &fuser::Request, ino: u64, fd: Option<u64>, reply: fuser::ReplyAttr) {
        println!("calling getattr with ino: {} fd: {:?}", ino, fd);

        let mut inode = Inode::load_from(&self.disk, ino).expect("error loading inode");
        reply.attr(&self.ttl(), &inode.to_file_attr());
    }

    fn readdir(&mut self, _req: &fuser::Request, ino: u64, _fh: u64, offset: i64, mut reply: fuser::ReplyDirectory) {
        println!("calling readdir with ino {:?}", ino);

        let mut inode = Inode::load_from(&self.disk, ino).expect("error loading inode");
        let dir_data = inode.get_dir_data(&self.disk);

        for (i, val) in dir_data.entries.iter().enumerate().skip(offset as usize) {
            let (name, entry) = val;

            let mut kind = FileType::RegularFile;
            if entry.kind == InodeKind::Dir {
                kind = FileType::Directory;
            }

            let _ = reply.add(entry.ino, i as i64 + 1, kind, name);
        }

        reply.ok();
    }

    // TODO: handle dir exists
    // TODO: handle parent is not dir
    fn mkdir(
        &mut self,
        _req: &fuser::Request,
        parent: u64,
        name: &std::ffi::OsStr,
        _mode: u32,
        _umask: u32,
        reply: fuser::ReplyEntry,
    ) {
        println!("calling mkdir with name {:?} for parent {}", name, parent);

        let mut parent = Inode::load_from(&self.disk, parent).expect("error loading parent");

        let mut child = Inode::new(InodeKind::Dir);
        let child_ino = child.save(&self.disk).expect("error saving child");

        let entry = DirEntry {
            ino: child_ino,
            name: String::from(self.to_string(name)),
            kind: InodeKind::Dir,
        };

        parent.update_entries(entry, &self.disk);
        let _ = parent.save(&self.disk);

        reply.entry(&self.ttl(), &child.to_file_attr(), 0);
    }
}

pub struct TinyFS {
    pub disk: Disk,
}



================================================
FILE: src/tiny/fs_extensions.rs
================================================
use std::{ffi::OsStr, time::Duration};

use super::TinyFS;

impl TinyFS {
    pub fn ttl(&mut self) -> Duration {
        Duration::new(1, 0)
    }

    pub fn to_string<'a>(&mut self, name: &'a OsStr) -> &'a str {
        if let Some(st) = name.to_str() {
            return st;
        } else {
            return "";
        }
    }
}



================================================
FILE: src/tiny/inode.rs
================================================
use std::{
    io::{BufReader, BufWriter, Cursor, Read, Seek, SeekFrom, Write},
    time::{Duration, SystemTime, UNIX_EPOCH},
};

use super::{
    bitmap::Bitmap,
    constants::{Block, Disk, InodeKind, BLOCK_SIZE, DATA_BLOCK_BASE, INODE_BLOCK_BASE},
    directory::{DirData, DirEntry},
};
use fuser::{FileAttr, FileType};
use serde::{Deserialize, Serialize};

impl Inode {
    pub fn new(kind: InodeKind) -> Inode {
        let now = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .expect("error creating time");

        Inode {
            ino: 0,
            kind,
            block_count: 0,
            size: 0,
            accessed_at: now.as_millis() as u64,
            modified_at: now.as_millis() as u64,
            created_at: now.as_millis() as u64,
            hard_links: 2,
            block_pointers: [0; 12],
        }
    }

    pub fn save(&mut self, disk: &Disk) -> Result<u64, bincode::Error> {
        let mut bm = Bitmap::from(disk);
        let now = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .expect("error creating time");

        let location: u64;
        if bm.is_inode_allocated(self.ino as usize) {
            println!("Inode {} is already allocated", self.ino);
            self.modified_at = now.as_millis() as u64;
            self.accessed_at = now.as_millis() as u64;
            location = Self::get_location(self.ino)
        } else {
            println!("Inode {} was not allocated", self.ino);
            let ino = bm.find_free_inode() as u64;
            self.ino = ino;
            location = Self::get_location(self.ino);
            bm.allocate_inode(self.ino as usize, &disk);
        }

        let mut buf = BufWriter::new(disk);

        let _ = buf.seek(SeekFrom::Start(location));
        self.serialize_into(&mut buf)?;
        let _ = buf.flush();

        Ok(self.ino)
    }

    pub fn load_from(disk: &Disk, ino: u64) -> Result<Inode, bincode::Error> {
        let location = Self::get_location(ino);
        let mut buf = BufReader::new(disk);
        let _ = buf.seek(SeekFrom::Start(location));

        let mut read_buf = [0; size_of::<Inode>()];
        let _ = buf.read_exact(&mut read_buf);
        bincode::deserialize_from(&mut read_buf.as_slice())
    }

    pub fn to_file_attr(&mut self) -> FileAttr {
        let mut kind = FileType::RegularFile;
        if self.kind == InodeKind::Dir {
            kind = FileType::Directory;
        }

        FileAttr {
            ino: self.ino,
            blksize: BLOCK_SIZE as u32,
            size: self.size as u64,
            blocks: self.block_count,
            atime: self.to_time(self.accessed_at),
            mtime: self.to_time(self.modified_at),
            crtime: self.to_time(self.created_at),
            ctime: self.to_time(self.created_at),
            kind,
            perm: 0o755,
            nlink: self.hard_links,
            uid: 1000,
            gid: 1003,
            rdev: 0,
            flags: 0,
        }
    }

    pub fn update_entries(&mut self, entry: DirEntry, disk: &Disk) {
        let mut bm = Bitmap::from(&disk);
        let mut dir_data = self.get_dir_data(&disk);

        for ptr in self.block_pointers {
            if ptr == 0 {
                break;
            }

            bm.free_data_block(ptr, &disk);
        }

        let name = entry.name.clone();
        dir_data.insert(&name, entry);

        self.save_dir_data(dir_data, &mut bm, &disk);
    }

    pub fn get_dir_data(&mut self, disk: &Disk) -> DirData {
        let mut buf = vec![];

        for ptr in self.block_pointers {
            if ptr == 0 {
                break;
            }

            let block = self.load_block(ptr, disk);
            buf.append(&mut block.to_vec());
        }

        if buf.len() > 0 {
            let s = &buf[..self.size + 1];
            return DirData::deserialize_from(s).expect("error getting dir data");
        }

        DirData::default()
    }

    pub fn save_dir_data(&mut self, mut data: DirData, bm: &mut Bitmap, disk: &Disk) {
        let data_buf = Vec::new();
        let mut write_buf = BufWriter::new(data_buf);
        let _ = data.serialize_into(&mut write_buf);
        let _ = write_buf.flush();
        let data_buf = write_buf.into_inner().expect("error getting inner buffer");

        self.size = data_buf.len();

        let (block_ptrs, block_count) = self.save_data_blocks(bm, data_buf, &disk);

        self.block_count = block_count as u64;
        self.block_pointers = block_ptrs;
    }

    fn load_block(&mut self, location: u64, disk: &Disk) -> Block {
        let mut block = [0; BLOCK_SIZE];

        let mut disk_buf = BufReader::new(disk);
        let _ = disk_buf.seek(SeekFrom::Start(location));
        disk_buf.read_exact(&mut block).expect("error reading block");

        block
    }

    // TODO:  throw error for files greater than 48KB in size
    fn save_data_blocks(&mut self, bitmap: &mut Bitmap, buf: Vec<u8>, disk: &Disk) -> ([u64; 12], usize) {
        let mut block_ptrs = [0u64; 12];
        let mut cursor = Cursor::new(buf);
        let mut chunk = [0u8; BLOCK_SIZE];
        let mut last_allocated = 0;

        while let Ok(n) = cursor.read(&mut chunk) {
            if n == 0 {
                println!("nothing more to read");
                break;
            }

            let mut write_buf = BufWriter::new(disk);
            let index = bitmap.find_free_data_block();
            let block_location = DATA_BLOCK_BASE + (index * BLOCK_SIZE) as u64;
            write_buf
                .seek(SeekFrom::Start(block_location))
                .expect("error seeking to block location");
            write_buf.write_all(&chunk).expect("error writing chunk");
            write_buf.flush().expect("error flushing buff");

            bitmap.allocate_data_block(index, &disk);
            block_ptrs[last_allocated] = block_location;
            last_allocated += 1;
        }

        (block_ptrs, last_allocated)
    }

    fn serialize_into<W: Write>(&mut self, buf: W) -> Result<(), bincode::Error> {
        bincode::serialize_into(buf, self)
    }

    fn to_time(&mut self, millis: u64) -> SystemTime {
        UNIX_EPOCH + Duration::from_millis(millis)
    }

    fn get_location(ino: u64) -> u64 {
        INODE_BLOCK_BASE + (ino * size_of::<Inode>() as u64)
    }
}

#[derive(Serialize, Deserialize, Debug, Clone, Copy)]
#[repr(C)]
pub struct Inode {
    pub ino: u64,
    pub kind: InodeKind,
    pub size: usize,
    pub block_count: u64,
    pub accessed_at: u64,
    pub modified_at: u64,
    pub created_at: u64,
    pub hard_links: u32,
    pub block_pointers: [u64; 12],
}



================================================
FILE: src/tiny/mod.rs
================================================
pub mod bitmap;
pub mod constants;
pub mod directory;
pub mod fs;
mod fs_extensions;
pub mod inode;
pub mod superblock;

pub use fs::TinyFS;



================================================
FILE: src/tiny/superblock.rs
================================================
use serde::{Deserialize, Serialize};
use std::io::{Read, Write};

#[derive(Deserialize, Serialize, Debug)]
pub struct Superblock {
    block_size: usize,
    block_count: u32,
}

impl Superblock {
    pub fn new(block_size: usize, block_count: u32) -> Superblock {
        Self {
            block_size,
            block_count,
        }
    }

    pub fn serialize_into<W: Write>(&mut self, buf: W) -> Result<(), bincode::Error> {
        bincode::serialize_into(buf, self)
    }

    pub fn deserialize_from<R: Read>(&mut self, buf: R) -> Result<Self, bincode::Error> {
        let super_block: Self = bincode::deserialize_from(buf)?;
        Ok(super_block)
    }
}

#[cfg(test)]
mod sb_tests {

    #[test]
    fn test_serialization() {
        println!("Hello, world!");
    }
}



================================================
FILE: .github/pull_request_template.md
================================================
## overview

## testing instructions



================================================
FILE: .github/workflows/release-please.yml
================================================
on:
  push:
    branches:
      - main

permissions:
  contents: write
  pull-requests: write

name: release-please

jobs:
  release-please:
    runs-on: ubuntu-latest
    steps:
      - name: checkout
        uses: actions/checkout@v3

      - name: Install stable toolchain
        uses: dtolnay/rust-toolchain@stable

      - uses: googleapis/release-please-action@v4
        id: release
        with:
          token: ${{ secrets.RELEASE_PLEASE_TOKEN }}
          release-type: simple 

      - name: upload release artifact
        if: ${{ steps.release.outputs.release_created }}
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: |
          cargo build --release
          gh release upload ${{ steps.release.outputs.tag_name }} ./target/release/tinyFS