作者：楊紅剛，蘭州大學

郵箱：[email protected] / [email protected]

--------------------------------------------------------------------

REF:
1. linux-3.6.9/fs/ramfs
2. Documentation/filesystems/ramfs-rootfs-initramfs.txt

目錄：

0. 檔案系統各個資料結構之間的聯絡圖

1. 分析了一個最簡單的Linux檔案系統ramfs的實現

   分析了最簡單的檔案系統ramfs的實現。

2. 最小檔案系統設計小結

    總結對ramfs的分析，得出最小檔案系統的設計實現關鍵。

3. 最小檔案系統例項

    該部分基本上覆制了ramfs的實現，通過該過程和修改相關的函式實現，可以研究

     每個函式的作用。加深對fs的理解。

-------------------------------------------------------------------------------------------------------------------

第零章 檔案系統各個資料結構之間的聯絡圖

在開始之前以ext4為例子先給出整個檔案系統的資料結構之間的關係圖。通過以後的

循序漸進的理解，最後就能理解整個圖的含義了。

高清圖下載

第一章 分析了一個最簡單的Linux檔案系統ramfs的實現

ramfs展示了怎樣設計一個虛擬檔案系統（virtual filesystem）。
它實現了一個符合POSIX規範的檔案系統的所有的邏輯。
該檔案系統沒有實現獨立的資料結構，僅僅利用了VFS中已經定義
結構。

ramfs將Linux磁碟緩衝匯出為一個可動態調整大小的基於RAM的檔案
系統。ramfs沒有後備儲存源。向ramfs中進行的檔案寫操作也會
分配目錄項和頁快取，但是資料並不寫回到任何其他儲存介質上。
這意味著涉及的記憶體頁不會被標記為“乾淨”狀態，這樣VM就不會
回收分配給ramfs的記憶體。

由於ramfs的實現完全基於已經存在的Linux緩衝機制，所以其程式碼
很少（不超過634行）。


首先，通過檢視Makefile檔案檢查ramfs依賴的模組。
obj-y += ramfs.o

file-mmu-y := file-nommu.o
file-mmu-$(CONFIG_MMU) := file-mmu.o
ramfs-objs += inode.o $(file-mmu-y)

可見ramfs-objs由inode.c，如果CONFIG_MMU配置為Y，那麼
還包括file-mmu.c，否則，包含file-nommu.c。
下面的討論假定CONFIG_MMU為Y。

--- include/linux/ramfs.h -----
該檔案中為ramfs模組對其他模組的介面。包括：

    函式
    ramfs_get_inode()
    ramfs_mount()
    init_rootfs()
    ramfs_fill_super()

    資料結構
    const struct file_operations ramfs_file_operations
    vm_operations_struct generic_file_vm_ops


------------------------------
---- fs/ramfs/file-mmu.c -----
------------------------------

該檔案中為ramfs_file_operations、ramfs_aops和ramfs_file_inode_operations
的具體初始化。

const struct address_space_operations ramfs_aops = {
    .readpage   = simple_readpage,
    .write_begin    = simple_write_begin,
    .write_end  = simple_write_end,
    .set_page_dirty = __set_page_dirty_no_writeback,
};
該結構中為ramfs的“地址空間”結構。"地址空間"結構，
將快取資料與其來源之間建立關聯。該結構用於ramfs向記憶體模組申請記憶體頁，並提供
從後備資料來源讀取資料並填充緩衝區以及將緩衝區中的資料寫入後備裝置等操作。


const struct file_operations ramfs_file_operations = {
    .read       = do_sync_read,
    .aio_read   = generic_file_aio_read,
    .write      = do_sync_write,
    .aio_write  = generic_file_aio_write,
    .mmap       = generic_file_mmap,
    .fsync      = noop_fsync,
    .splice_read    = generic_file_splice_read,
    .splice_write   = generic_file_splice_write,
    .llseek     = generic_file_llseek,
};
該結構為ramfs中檔案的通用檔案操作函式集合。

const struct inode_operations ramfs_file_inode_operations = {
    .setattr    = simple_setattr,
    .getattr    = simple_getattr,
};
尬結構包括ramfs的檔案節點操作函式集合。


-------------------------
---- fs/ramfs/inode.c ---
-------------------------

ramfs的模組初始化函式：
static int __init init_ramfs_fs(void);
呼叫核心函式register_filesystem()註冊ramfs。
關於ramfs的描述結構rootfs_fs_type的初始化如下：
static struct file_system_type ramfs_fs_type = {
    .name       = "ramfs",
    .mount      = ramfs_mount,
    .kill_sb    = ramfs_kill_sb,
};
"ramfs"為檔案系統的名字。
ramfs_mount為ramfs的掛載操作。
ramfs_kill_sb為不再需要ramfs檔案系統時執行相關清理工作。


------------------------------------------------------
作用：初始化ramfs的超級塊。
註釋：包括掛載引數，根inode和根目錄項等的初始化。
int ramfs_fill_super(struct super_block *sb, void *data, int silent);

 [1] 將檔案系統的掛載引數儲存到sb.s_options欄位。該值用於generic_show_options()
函式對檔案系統掛載引數的顯示操作。
 [2] 分配ramfs特有的ramfs_fs_info結構。其原型為：

struct ramfs_mount_opts {
    umode_t mode;
};

struct ramfs_fs_info {
    struct ramfs_mount_opts mount_opts;
};
 [3] 指向ramfs_fs_info結構的指標存放在ramfs的超級塊的私有欄位s_fs_info中。
 [4] 呼叫ramfs_parse_options()對掛載引數進行解析。將掛載引數“mode=XX”中的
　　 XX儲存在ramfs_mount_opts的mode欄位。預設值為0755。其他掛載引數都被忽略。
 [5] 初始化超級塊的s_maxbytes為MAX_LFS_FILESIZE。該欄位表示最大的檔案長度。
　　 初始化超級塊的s_blocksize欄位為PAGE_CACHE_SIZE。該欄位表示檔案系統塊的長度，
　　 單位為位元組。另一個欄位為s_blocksize_bits欄位，該欄位也表示檔案系統塊的長度，
　　 只是它為s_blocksize取以2為底的對數。
     初始化超級塊的s_magic欄位，該欄位為超級塊的魔數，用於檢查超級塊的損壞。
　　 初始化超級塊的s_op欄位為ramfs_ops。該結構包含了用於處理超級塊的相關操作。
 
static const struct super_operations ramfs_ops = {
    .statfs     = simple_statfs, //給出檔案系統的統計資訊，例如使用和未使用的資料塊的數目，或者檔案件名的最大長度。  
    .drop_inode = generic_delete_inode, //當inode的引用計數降為0時，將inode刪除。
    .show_options   = generic_show_options, //用以顯示檔案系統裝載的選項。
};

     初始化超級塊的s_time_gran欄位。它表示檔案系統支援的各種時間戳的最大可能的粒度。單位為ns。
 [6] 呼叫ramfs_get_inode()為ramfs超級塊在生成一個代表根節點inode。並將inode各個欄位進行初始化。最後，返回
　　 指向該根inode的指標。(具體操作詳見下文分析。)
 [7] 呼叫d_make_root()為根inode建立並初始化一個目錄項。

------------------------------------------------------
作用：查詢或者建立一個VFS超級塊super_block結構。執行ramfs_fill_supper()對ramfs的超級
　　　塊進行初始化。然後，對根目錄的目錄項引用計數增一。
struct dentry *ramfs_mount(struct file_system_type *fs_type,
        int flags, const char *dev_name, void *data);

-----------------------------------------------

static void ramfs_kill_sb(struct super_block *sb)

[1] 釋放ramfs私有的資料結構ramfs_fs_info。
[2] 呼叫kill_litter_super()執行對超級塊的清理操作。


------------------------------------------------------
struct inode *ramfs_get_inode(struct super_block *sb,
                const struct inode *dir, umode_t mode, dev_t dev)

[1] 呼叫new_inode()建立一個符合ramfs型別的inode結構。
[2] 初始化inode的編號。
　　初始化inode的uid, gid, mode欄位。
　　初始化inode的“地址空間”的操作集合為ramfs_aops，該操作集合和ramfs檔案內容讀寫相關。
    初始化inode的後備儲存裝置的有關資訊為ramfs_backing_dev_info。後備儲存裝置是與“地址空間”相關的外部裝置，是資料的來源和去向。

    為inode的flags欄位新增GFP_HIGHUSER標記。flags欄位標誌集主要用於儲存對映頁所來自的GFP記憶體區的有關資訊。該欄位也可以
　　用來儲存非同步傳輸期間發生的錯誤資訊，在非同步傳輸期間錯誤無法直接傳遞給呼叫者。AS_EIO表示一般性I/O錯誤，AS_ENOSPC表示沒有足夠的空間
　　來完成一個非同步寫操作。GFP_HIGHUSER表示儲存記憶體頁的實體記憶體優先從高階記憶體區域獲取。
    
    為inode的flags新增AS_UNEVICTABLE標誌。這樣ramfs涉及的記憶體頁就會放入unevictable_list中，這些記憶體頁不會再被回收。
    
    初始化inode的i_atime, i_mtime, i_ctime為當前時間。

[3] 根據mode的設定為inode設定四種不同操作集：
    - REG//普通檔案
        設定inode的i_op為ramfs_file_inode_operations操作集。
　　　　設定inode的i_fop為ramfs_file_operations操作集。    
    - DIR//資料夾
        設定inode的i_op為ramfs_dir_inode_operations操作集。
　　　　設定inode的i_fop為simple_dir_operations操作集。
    - LINK//連結    
        設定i_op為page_symlink_inode_operations操作集。
[4] 將初始化好的inode的指標返回。

--------- 地址空間操作　-------------------
const struct address_space_operations ramfs_aops = {
    .readpage   = simple_readpage,
    .write_begin    = simple_write_begin,
    .write_end  = simple_write_end,
    .set_page_dirty = __set_page_dirty_no_writeback,
};
simple_readpage: 用於從後備儲存器將一頁資料讀入頁框。對於ramfs沒有後備儲存器，只有RAM。

simple_write_begin:
　　根據檔案的讀寫位置pos計算出檔案的頁偏移值。
    根據索引查詢或者分配一個page結構。
　　將頁中資料初始化為“０”。

simple_write_end: 在對page執行寫入操作後，執行相關更新操作。

__set_page_dirty_no_writeback: 將某個頁標記為“髒”。但是並不執行寫回操作，
　　因為ramfs不需要寫回到磁碟。這也是為什麼ramfs重寫掛載後，之前寫入的資料丟失的原因。


------------ 後備儲存器　-----------------
static struct backing_dev_info ramfs_backing_dev_info = {
    .name       = "ramfs",
    .ra_pages   = 0,    /* No readahead */
    .capabilities   = BDI_CAP_NO_ACCT_AND_WRITEBACK |
              BDI_CAP_MAP_DIRECT | BDI_CAP_MAP_COPY |
              BDI_CAP_READ_MAP | BDI_CAP_WRITE_MAP | BDI_CAP_EXEC_MAP,
};
該結構描述了作為資料來源和去向的後備儲存裝置的相關描述資訊。

ra_pages: 設定了最大預讀數量。
BDI_CAP_NO_ACCT_AND_WRITEBACK 不需要寫回、不執行髒頁統計、不自動計算回寫頁統計。
BDI_CAP_MAP_DIRECT 可以直接對映。
BDI_CAP_MAP_COPY　拷貝可以被對映。
BDI_CAP_READ_MAP　可以對映讀取。
BDI_CAP_WRITE_MAP　可以對映寫。
BDI_CAP_EXEC_MAP　可以被對映執行程式碼。

----------- 檔案節點操作集 ------------

const struct inode_operations ramfs_file_inode_operations = {
    .setattr    = simple_setattr,
    .getattr    = simple_getattr,
};

simple_setattr: 一個簡單的屬性設定函式。僅僅針對記憶體檔案系統或者特殊的檔案系統。
　　如果需要在檔案大小改變時也對磁碟上的元資料進行修改那麼需要檔案系統提供相關
　　的修改方法。
simple_getattr: 獲取檔案的相關屬性資訊，如ino，mode，nlink, uid, gid 等等。

-------------　檔案操作集　----------------

const struct file_operations ramfs_file_operations = {
    .read       = do_sync_read,
    .aio_read   = generic_file_aio_read,
    .write      = do_sync_write,
    .aio_write  = generic_file_aio_write,
    .mmap       = generic_file_mmap,
    .fsync      = noop_fsync,
    .splice_read    = generic_file_splice_read,
    .splice_write   = generic_file_splice_write,
    .llseek     = generic_file_llseek,
};

全部為VFS層提供的通用的檔案操作方法。

------------ 資料夾節點操作集　-------

static const struct inode_operations ramfs_dir_inode_operations = {
    .create     = ramfs_create,
    .lookup     = simple_lookup,
    .link       = simple_link,
    .unlink     = simple_unlink,
    .symlink    = ramfs_symlink,
    .mkdir      = ramfs_mkdir,
    .rmdir      = simple_rmdir,
    .mknod      = ramfs_mknod,
    .rename     = simple_rename,
};  

static int ramfs_create(struct inode *dir, struct dentry *dentry, umode_t mode, bool excl)
        ：在目錄@dir下，建立一個普通檔案，並在@dir下建立一個和檔案關聯的目錄項@dentry。

simple_lookup：通用的查詢操作。根據檔案系統物件的名字（字串）查詢對應的inode例項。???
   為目錄項設定d_delete欄位為simple_delete_dentry()。
   並將目錄項新增到目錄項的hash表上，方便快速查詢。
int simple_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
   建立硬連結。建立從@dir下的@dentry目錄項到@old_dentry目錄項管理的inode的硬連結。
simple_unlink: 為ssimple_link()的逆操作。

static int ramfs_symlink(struct inode * dir, struct dentry *dentry, const char * symname)
  在目錄@dir下新建並初始化一個連結inode，連結的路徑名為@symname。

static int ramfs_mkdir(struct inode * dir, struct dentry * dentry, umode_t mode)
  在目錄@dir下，建立一個目錄項inode並和@dentry相關聯。
simple_rmdir: ramfs_mkdir的逆操作。

ramfs_mknod: 在@dir下分配和初始化一個裝置inode，並和@dentry相關聯。　


------------ simple_dir_operations ----------
const struct file_operations simple_dir_operations = {
    .open       = dcache_dir_open,
    .release    = dcache_dir_close,
    .llseek     = dcache_dir_lseek,
    .read       = generic_read_dir,
    .readdir    = dcache_readdir,
    .fsync      = noop_fsync,
};  

ramfs資料夾操作直接使用了simple_dir_operations。

第二章 最小檔案系統設計小結

********** 小結：最小檔案系統設計

1. 需要的操作

   - 檔案系統註冊
     使用register_filesystem()向核心註冊檔案系統。
   - 檔案系統解除安裝
     使用unregister_filesystem()來解除安裝檔案系統。

2. 需要提供的資料結構

   在使用register_filesystem()向核心註冊檔案系統時，需要提供一個[1] struct file_system_type的例項，
   該例項描述了檔案系統的基本資訊。主要包括@name，檔案系統的名字。@mount檔案系統的掛載相關的操作，
   掛載時需要提供初始化超級塊（super_block）的操作。@kill_sb提供了對超級塊的清理操作。
 
   在初始化檔案系統超級塊時需要指定超級塊相關的操作集合。這需要填充一個[2] struct super_operations結構。
   主要有@statfs，用於給出檔案系統的統計資訊，例如未使用的資料塊的數目、檔名的最大長度等。
   @drop_inode，用於當inode的引用計數降為0時，將inode刪除。
   @show_options，用於顯示檔案系統的裝載選項。

   在分配新的inode時，需要初始化inode的相關操作。這需要初始化一個[3] struct address_space_operations。
   該結構為“地址空間”的操作集。“地址空間”建立了記憶體中資料和其資料來源之間的關聯。當需要更多的物理
   記憶體時，負責向記憶體模組申請記憶體。並提供從後備資料來源讀取資料並填充記憶體緩衝區以及將更新後的資料
   寫回到後備裝置等操作。其中@readpage用於將一頁資料讀取頁框。通常初始化為核心的標準函式mpage_readpage。
   在ramfs中初始化為simple_readpage。@write_begin函式被通用的緩衝區寫函式呼叫，用來告知檔案系統
   準備好向檔案的特定偏移處寫若干個位元組的操作。檔案系統根據需要分配相關的記憶體空間等等。
   在成功地進行了@readpage和資料拷貝後，必須呼叫@write_end。
   @set_page_dirty被VM呼叫，來將一個頁標記為髒。應該設定頁的PageDirty標記和基樹的PAGECACHE_TAG_DIRTY的標記。

   [4] struct backing_dev_info包含了與“地址空間”相關的後備儲存器的有關資訊。後備儲存器是指與地址空間
   相關的外部裝置，用作地址空間中資料的來源，通常為塊裝置。@name是後備儲存裝置的名字。@ra_pages為最大預讀
   的數量，單位為PaGE_CACHE_SIZE。@capabilities中最重要的資訊是資料頁是否可以回寫。比如，BDI_CAP_NO_ACCT_AND_WRITEBACK
   表示不需要回寫、不執行髒頁統計、不自動計算回寫頁統計。

   [5] struct inode_operations 為資料夾節點相關的操作集。主要包括在指定目錄下建立/刪除普通檔案、裝置檔案、目錄檔案、
   連結檔案和查詢以及重新命名等相關操作。
   [6] struct file_operations 資料夾相關的操作集合。

   [7] struct inode_operations 為檔案節點相關的操作集。
   [8] struct file_operations 檔案相關的操作集。


第三章 最小檔案系統例項

*********** 最小檔案系統例項

wendyfs是為了方便讀者快速掌握Linux檔案系統的設計而從ramfs中抽取出來的一個基於RAM的檔案系統。具體實現
參見wendyfs.c。使用方法相見README。
在實現中註釋掉了wendyfs_dir_inode_operations中的.rename操作，這樣wendyfs中就無法使用重新命名操作。比如，
mv fileA fileB。這樣可以研究每一個方法的作用。

//wendyfs.c

/*
   * 本模組程式碼大部分拷貝自fs/ramfs/inode.c和fs/ramfs/file-mmu.c。
   * 主要實現了一個RAM檔案系統的基本功能（除了檔案重新命名 mv fileA fileB）
   * 本模組可以幫助我們學習Linux檔案系統。 
*/


#include <linux/fs.h> /* super_operations */
#include <linux/module.h>
#include <linux/init.h>
#include <linux/pagemap.h> /*mapping_set_unevictable() */
#include <linux/time.h> /* CURRENT_TIME */ 
#include <linux/backing-dev.h> 



//should be defined in the heaeder files
#define WENDYFS_MAGIC     0xa5a5a5a5


struct inode *wendyfs_get_inode(struct super_block *sb,
                const struct inode *dir, umode_t mode, dev_t dev);
int myset_page_dirty_no_writeback(struct page *page);


/* Wendyfs's address space operations */
const struct address_space_operations wendyfs_aops = {
		.readpage	= simple_readpage,
		.write_begin	= simple_write_begin,
		.write_end		= simple_write_end,
		.set_page_dirty	= myset_page_dirty_no_writeback,
};

static struct backing_dev_info wendyfs_backing_dev_info = { 
    .name       = "wendyfs",
    .ra_pages   = 0,    /* No readahead */
    .capabilities   = BDI_CAP_NO_ACCT_AND_WRITEBACK |
              BDI_CAP_MAP_DIRECT | BDI_CAP_MAP_COPY |
              BDI_CAP_READ_MAP | BDI_CAP_WRITE_MAP | BDI_CAP_EXEC_MAP,
};


/*
 * For address_spaces which do not use buffers nor write back.
 */
int myset_page_dirty_no_writeback(struct page *page)
{
    if (!PageDirty(page))
        return !TestSetPageDirty(page);
    return 0;
}


/* File creation */
static int wendyfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev)
{
	int error = -ENOSPC;
	struct inode* inode = wendyfs_get_inode(dir->i_sb, dir, mode, dev);

	if (inode) {
		d_instantiate(dentry, inode);
		dget(dentry);   /* Extra count - pin the dentry in core */
		error = 0;
		dir->i_mtime = dir->i_ctime = CURRENT_TIME;
	}

	return error;
}

static int wendyfs_mkdir(struct inode * dir, struct dentry * dentry, umode_t mode)
{
	int retval = wendyfs_mknod(dir, dentry, mode | S_IFDIR, 0); // DIR inode
  	if (!retval)
			inc_nlink(dir);

	return retval;
}


static int wendyfs_create(struct inode *dir, struct dentry *dentry, umode_t mode, bool excl)
{
    return wendyfs_mknod(dir, dentry, mode | S_IFREG, 0); 
}


static const struct inode_operations wendyfs_dir_inode_operations = {
	.create		= wendyfs_create,
	.lookup		= simple_lookup,
	.mkdir		= wendyfs_mkdir,
	.rmdir		= simple_rmdir,
	.link		= simple_link,
	.unlink		= simple_unlink,
//	.rename		= simple_rename, 
};


const struct inode_operations wendyfs_file_inode_operations = {
	.setattr	= simple_setattr,
	.getattr	= simple_getattr,
};


const struct file_operations wendyfs_file_operations = {
    .read       = do_sync_read,
    .aio_read   = generic_file_aio_read,
    .write      = do_sync_write,
    .aio_write  = generic_file_aio_write,
    .fsync      = noop_fsync,
    .llseek     = generic_file_llseek,
};

struct inode *wendyfs_get_inode(struct super_block *sb,
                const struct inode *dir, umode_t mode, dev_t dev) 
{
	/* Allocate one inode */
    struct inode * inode = new_inode(sb); 

	/* Init the inode */
    if (inode) {
		inode->i_ino = get_next_ino();

		/* Init uid,gid,mode for new inode according to posix standards */
	    inode_init_owner(inode, dir, mode);
		
		/* Set the address space operation set */
		inode->i_mapping->a_ops = &wendyfs_aops;
		
		/* Set the backing device info */
		inode->i_mapping->backing_dev_info = &wendyfs_backing_dev_info;
		
		/* The pages wendyfs covered will be placed on unevictable_list. So
		   these pages will not be reclaimed. */
		mapping_set_unevictable(inode->i_mapping);
		inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
		
		/* Set inode and file operation sets */
		switch (mode & S_IFMT) {
		default: 
				init_special_inode(inode, mode, dev);
				break;
		case S_IFDIR:
				/* dir inode operation set */
				inode->i_op = &wendyfs_dir_inode_operations;
				/* dir operation set */
				inode->i_fop = &simple_dir_operations;
				inc_nlink(inode);
				break;
		case S_IFREG:
				/* regular file inode operation set */
				inode->i_op = &wendyfs_file_inode_operations;
				/* regular file operation set */
				inode->i_fop = &wendyfs_file_operations;
				break;
		}
	}

	return inode;
}

/* Super Block related operations */
static const struct super_operations wendyfs_ops = { 
    .statfs     = simple_statfs,
    .drop_inode = generic_delete_inode,
    .show_options   = generic_show_options,
};


int wendyfs_fill_super(struct super_block* sb, void* data, int silent)
{
	struct inode *inode;

	sb->s_maxbytes		= 4096;
	sb->s_blocksize		= 4096;
	sb->s_blocksize_bits	= 12;
	sb->s_magic			= WENDYFS_MAGIC;
	/* Set super block operations */
	sb->s_op			= &wendyfs_ops;
	sb->s_time_gran		= 1;

	/* Create and initialize the root inode */
	inode = wendyfs_get_inode(sb, NULL, S_IFDIR, 0);
	sb->s_root = d_make_root(inode);
	if (!sb->s_root)
			return -ENOMEM;

	return 0;
}



struct dentry* wendyfs_mount(struct file_system_type *fs_type,
				int flags, const char* dev_name, void* data)
{
	return mount_nodev(fs_type, flags, data, wendyfs_fill_super);
}

static void wendyfs_kill_sb(struct super_block* sb)
{
	kill_litter_super(sb);
}

static struct file_system_type	wendy_fs_type = {
		.name		= "wendyfs",
		.mount		= wendyfs_mount,
		.kill_sb	= wendyfs_kill_sb,
};


static int __init init_wendy_fs(void)
{
		return register_filesystem(&wendy_fs_type);
}

static void __exit exit_wendy_fs(void)
{
	unregister_filesystem(&wendy_fs_type);
}


module_init(init_wendy_fs)
module_exit(exit_wendy_fs)

MODULE_AUTHOR("Yang Honggang, <[email protected]>");
MODULE_LICENSE("GPL");

//README

Howto use:
0. Compile wendyfs module
   $make

1. Insert wendyfs module
	#insmod wendyfs.ko
2. Check the filesystem list
    #cat /proc/filesystems
    ...
	nodev	wendyfs
3. Mount the wendyfs 
    #mount -t wendyfs none /mnt
4. Create a dir in the mount point
    #cd /mnt
    #mkdir hello
5. Delete the hello dir
    #rm -rf hello
6. Create a file and rename it
   #echo "hello" > halo
   #cat halo
   #mv halo hello
   mv: cannot move `halo' to `hello': Operation not permitted
   ...

Makefile

obj-m := wendyfs.o
default:
	make -C /lib/modules/`uname -r`/build M=`pwd` modules	
clean:
	rm modules.order Module.symvers *.ko *.mod.* *.o .tmp_versions/ .*cmd -rf