Import from internal tree

Author: jserv

.clang-format

@@ -0,0 +1,15 @@
+BasedOnStyle: Chromium
+Language: Cpp
+MaxEmptyLinesToKeep: 3
+IndentCaseLabels: false
+AllowShortIfStatementsOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+DerivePointerAlignment: false
+PointerAlignment: Right
+SpaceAfterCStyleCast: true
+TabWidth: 4
+UseTab: Never
+IndentWidth: 4
+BreakBeforeBraces: Linux
+AccessModifierOffset: -4

.gitignore

@@ -0,0 +1,56 @@
+# Prerequisites
+*.d
+
+# Object files
+*.o
+*.ko
+*.obj
+*.elf
+
+# Linker output
+*.ilk
+*.map
+*.exp
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Libraries
+*.lib
+*.a
+*.la
+*.lo
+
+# Shared objects
+*.dll
+*.so
+*.so.*
+*.dylib
+
+# Executables
+*.exe
+*.out
+*.app
+*.i*86
+*.x86_64
+*.hex
+mkfs.simplefs
+
+# Debug files
+*.dSYM/
+*.su
+*.idb
+*.pdb
+
+# Kernel Module Compile Results
+*.mod*
+*.cmd
+.tmp_versions/
+modules.order
+Module.symvers
+Mkfile.old
+dkms.conf
+
+# Other
+test.img

LICENSE

@@ -0,0 +1,26 @@
+simplefs is freely redistributable under the two-clause BSD License:
+
+Copyright (C) 2020 National Cheng Kung University, Taiwan.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright notice,
+   this list of conditions and the following disclaimer.
+2. 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.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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.

Makefile

@@ -0,0 +1,26 @@
+obj-m += simplefs.o
+simplefs-objs := fs.o super.o inode.o file.o dir.o
+
+KDIR ?= /lib/modules/$(shell uname -r)/build
+
+MKFS = mkfs.simplefs
+
+all: $(MKFS)
+	make -C $(KDIR) M=$(PWD) modules
+
+IMAGE ?= test.img
+IMAGESIZE ?= 50
+
+$(MKFS): mkfs.c
+	$(CC) -Wall -o $@ $<
+
+$(IMAGE): $(MKFS)
+	dd if=/dev/zero of=${IMAGE} bs=1M count=${IMAGESIZE}
+	./$< $(IMAGE)
+
+clean:
+	make -C $(KDIR) M=$(PWD) clean
+	rm -f *~ $(PWD)/*.ur-safe
+	rm -f $(MKFS) $(IMAGE)
+
+.PHONY: all clean

README.md

@@ -0,0 +1,86 @@
+# simplefs - a simple file system for Linux
+
+The file system "simplefs" is helpful to understand Linux VFS and file system basics.
+The Linux VFS supports multiple file systems. The kernel does most of the work while the file system specific tasks are delegated to the individual file systems through the handlers. Instead of calling the functions directly the kernel uses various Operation Tables, which are a collection of handlers for each operation (these are actually structures of function pointers for each handlers/callbacks). 
+
+The super block operations are set at the time of mounting. The operation tables for inodes and files are set when the inode is opened. The first step before opening an inode is lookup. The inode of a file is looked up by calling the lookup handler of the parent inode. 
+
+## Current features
+
+* Directories: create, remove, list, rename;
+* Regular files: create, remove, read/write (through page cache), rename;
+* No extended attribute support
+
+## Build and Run
+
+You can build the kernel module and tool with `make`.
+Generate test image via `make test.img`, which creates a zeroed file of 50 MiB.
+
+You can then mount this image on a system with the simplefs kernel module installed.
+```shell
+sudo insmod simplefs.ko
+mkdir -p test
+sudo mount -o loop -t simplefs test.img test
+sudo umount test
+sudo rmmod simplefs
+```
+
+## Design
+
+At present, simplefs only provides straightforward features.
+
+### Partition layout
+```
+    +------------+-------------+-------------------+-------------------+-------------+
+    | superblock | inode store | inode free bitmap | block free bitmap | data blocks |
+    +------------+-------------+-------------------+-------------------+-------------+
+```
+Each block is 4 KiB large.
+
+### Superblock
+The superblock is the first block of the partition (block 0). It contains the partition's metadata, such as the number of blocks, number of inodes, number of free inodes/blocks, ...
+
+### Inode store
+Contains all the inodes of the partition. The maximum number of inodes is equal to the number of blocks of the partition. Each inode contains 40 B of data: standard data such as file size and number of used blocks, as well as a simplefs-specific field called `index_block`. This block contains:
+  - for a directory: the list of files in this directory. A directory can contain at most 128 files, and filenames are limited to 28 characters to fit in a single block.
+  ```
+  inode
+  +-----------------------+
+  | i_mode = IFDIR | 0755 |            block 123
+  | index_block = 123 ----|-------->  +-----------+
+  | i_size = 4 KiB        |         0 | 24 (foo)  |
+  | i_blockcs = 1         |           |-----------|
+  +-----------------------+         1 | 45 (bar)  |
+                                      |-----------|
+                                        ...
+                                      |-----------|
+                                  127 | 0         |
+                                      +-----------+
+  ```
+  - for a file: the list of blocks containing the actual data of this file. Since block IDs are stored as 32-bit values, at most 1024 links fit in a single block, limiting the size of a file to 4 MiB.
+  ````
+  inode                                                block 94
+  +-----------------------+                           +--------+
+  | i_mode = IFDIR | 0644 |          block 93         |        |    block 99
+  | index_block =93 ----|-------->  +---------+       |        |   +--------+
+  | i_size = 10 KiB        |      0 | 94   ---|-----> +--------+   |        |
+  | i_blockcs = 4         |         |---------|                    |        |
+  +-----------------------+       1 | 99   ---|------------------> +--------+
+                                    |---------|
+                                  2 | 66   ---|----->  block 66
+                                    |---------|       +--------+
+                                      ...             |        |
+                                    |---------|       |        |
+                                127 | 0       |       +--------+
+                                    +---------+
+  ```
+
+## TODO
+- support for extents
+- hard/symbolic link
+- journalling support
+
+## License
+
+`simplefs` is released under the BSD 2 clause license. Use of this source code is governed by
+a BSD-style license that can be found in the LICENSE file.

bitmap.h

@@ -0,0 +1,88 @@
+#ifndef SIMPLEFS_BITMAP_H
+#define SIMPLEFS_BITMAP_H
+
+#include <linux/bitmap.h>
+#include "simplefs.h"
+
+/*
+ * Return the first free bit (set to 1) in a given in-memory bitmap spanning
+ * over multiple blocks and clear it.
+ * Return 0 if no free bit found (we assume that the first bit is never free
+ * because of the superblock and the root inode, thus allowing us to use 0 as an
+ * error value).
+ */
+static inline uint32_t get_first_free_bit(unsigned long *freemap,
+                                          unsigned long size)
+{
+    uint32_t ino = find_first_bit(freemap, size);
+    if (ino == size)
+        return 0;
+
+    bitmap_clear(freemap, ino, 1);
+
+    return ino;
+}
+
+/*
+ * Return an unused inode number and mark it used.
+ * Return 0 if no free inode was found.
+ */
+static inline uint32_t get_free_inode(struct simplefs_sb_info *sbi)
+{
+    uint32_t ret = get_first_free_bit(sbi->ifree_bitmap, sbi->nr_inodes);
+    if (ret)
+        sbi->nr_free_inodes--;
+    return ret;
+}
+
+/*
+ * Return an unused block number and mark it used.
+ * Return 0 if no free block was found.
+ */
+static inline uint32_t get_free_block(struct simplefs_sb_info *sbi)
+{
+    uint32_t ret = get_first_free_bit(sbi->bfree_bitmap, sbi->nr_blocks);
+    if (ret)
+        sbi->nr_free_blocks--;
+    return ret;
+}
+
+/*
+ * Mark the i-th bit in freemap as free (i.e. 1)
+ */
+static inline int put_free_bit(unsigned long *freemap,
+                               unsigned long size,
+                               uint32_t i)
+{
+    /* i is greater than freemap size */
+    if (i > size)
+        return -1;
+
+    bitmap_set(freemap, i, 1);
+
+    return 0;
+}
+
+/*
+ * Mark an inode as unused.
+ */
+static inline void put_inode(struct simplefs_sb_info *sbi, uint32_t ino)
+{
+    if (put_free_bit(sbi->ifree_bitmap, sbi->nr_inodes, ino))
+        return;
+
+    sbi->nr_free_inodes++;
+}
+
+/*
+ * Mark a block as unused.
+ */
+static inline void put_block(struct simplefs_sb_info *sbi, uint32_t bno)
+{
+    if (put_free_bit(sbi->bfree_bitmap, sbi->nr_blocks, bno))
+        return;
+
+    sbi->nr_free_blocks++;
+}
+
+#endif /* SIMPLEFS_BITMAP_H */

dir.c

@@ -0,0 +1,65 @@
+#define pr_fmt(fmt) "simplefs: " fmt
+
+#include <linux/buffer_head.h>
+#include <linux/fs.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+
+#include "simplefs.h"
+
+/*
+ * Iterate over the files contained in dir and commit them in ctx.
+ * This function is called by the VFS while ctx->pos changes.
+ * Return 0 on success.
+ */
+static int simplefs_iterate(struct file *dir, struct dir_context *ctx)
+{
+    struct inode *inode = file_inode(dir);
+    struct simplefs_inode_info *ci = SIMPLEFS_INODE(inode);
+    struct super_block *sb = inode->i_sb;
+    struct buffer_head *bh = NULL;
+    struct simplefs_dir_block *dblock = NULL;
+    struct simplefs_file *f = NULL;
+    int i;
+
+    /* Check that dir is a directory */
+    if (!S_ISDIR(inode->i_mode))
+        return -ENOTDIR;
+
+    /*
+     * Check that ctx->pos is not bigger than what we can handle (including
+     * . and ..)
+     */
+    if (ctx->pos > SIMPLEFS_MAX_SUBFILES + 2)
+        return 0;
+
+    /* Commit . and .. to ctx */
+    if (!dir_emit_dots(dir, ctx))
+        return 0;
+
+    /* Read the directory index block on disk */
+    bh = sb_bread(sb, ci->index_block);
+    if (!bh)
+        return -EIO;
+    dblock = (struct simplefs_dir_block *) bh->b_data;
+
+    /* Iterate over the index block and commit subfiles */
+    for (i = ctx->pos - 2; i < SIMPLEFS_MAX_SUBFILES; i++) {
+        f = &dblock->files[i];
+        if (!f->inode)
+            break;
+        if (!dir_emit(ctx, f->filename, SIMPLEFS_FILENAME_LEN, f->inode,
+                      DT_UNKNOWN))
+            break;
+        ctx->pos++;
+    }
+
+    brelse(bh);
+
+    return 0;
+}
+
+const struct file_operations simplefs_dir_ops = {
+    .owner = THIS_MODULE,
+    .iterate_shared = simplefs_iterate,
+};