wrapfs 学习之一：头文件wrapfs.h

//wrapfs file 的私有数据，用于记录lower level fs file

/* file private data */

struct wrapfs_file_info {　　　
struct file *lower_file;　　　　//lower level fs file
const struct vm_operations_struct *lower_vm_ops;
};

//wrapfs inode 数据结构，它包括wrapfs自身inode，及lower level fs inode
/* wrapfs inode data in memory */
struct wrapfs_inode_info {
struct inode *lower_inode;　　     //lower level fs inode
struct inode vfs_inode;                // wrapfs自身inode
};

//wrapfs dentry 数据结构，它包括low level fs wrapfs dentry和vfsmount
/* wrapfs dentry data in memory */
struct wrapfs_dentry_info {
spinlock_t lock;/* protects lower_path */
struct path lower_path;        //low level fs dentry和vfsmount
};

//wrapfs sb 数据结构，它记录的lower level fs sb，也可以添加wrapfs专有数据
/* wrapfs super-block data in memory */
struct wrapfs_sb_info {

struct super_block *lower_sb;   //lower level fs sb

        。。。。。。  // 可以添加一些wrapfs sb专有数据

};

/*
 * inode to private data
 *
 * Since we use containers and the struct inode is _inside_ the
 * wrapfs_inode_info structure, WRAPFS_I will always (given a non-NULL
 * inode pointer), return a valid non-NULL pointer.

 */

//从wrapfs inode 数据结构获取 wrapfs_inode_info，它包括lower level fs inode

static inline struct wrapfs_inode_info *WRAPFS_I(const struct inode *inode)
{
return container_of(inode, struct wrapfs_inode_info, vfs_inode);
}

/* dentry to private data */

//  dentry 私有数据指针存放：wrapfs_dentry_info数据结构 ,

#define WRAPFS_D(dent) ((struct wrapfs_dentry_info *)(dent)->d_fsdata)

===============================================================

/* allocate new dentry private data */
int new_dentry_private_data(struct dentry *dentry)
{
struct wrapfs_dentry_info *info = WRAPFS_D(dentry);


/* use zalloc to init dentry_info.lower_path */
info = kmem_cache_zalloc(wrapfs_dentry_cachep, GFP_ATOMIC);
if (!info)
return -ENOMEM;


spin_lock_init(&info->lock);
dentry->d_fsdata = info;


return 0;
}

===================================================================

/* superblock to private data */

//  superblock 私有数据指针存放：wrapfs_sb_info数据结构 ,

#define WRAPFS_SB(super) ((struct wrapfs_sb_info *)(super)->s_fs_info)

/* file to private Data */

//  file 私有数据指针存放：wrapfs_file_info数据结构 ,

#define WRAPFS_F(file) ((struct wrapfs_file_info *)((file)->private_data))

/* file to lower file */

//从wrapfs_file_info数据结构获取low level fs file 

static inline struct file *wrapfs_lower_file(const struct file *f)
{
return WRAPFS_F(f)->lower_file;
}

//保存low level fs file到wrapfs_file_info数据结构
static inline void wrapfs_set_lower_file(struct file *f, struct file *val)
{
WRAPFS_F(f)->lower_file = val;
}

/* inode to lower inode. */

//从wrapfs_inode_info获取low level fs inode

static inline struct inode *wrapfs_lower_inode(const struct inode *i)
{
return WRAPFS_I(i)->lower_inode;
}

//保存low level fs inode到wrapfs_inode_info数据结构
static inline void wrapfs_set_lower_inode(struct inode *i, struct inode *val)
{
WRAPFS_I(i)->lower_inode = val;
}

//从wrapfs_sb_info获取low level fs sb
/* superblock to lower superblock */
static inline struct super_block *wrapfs_lower_super(
const struct super_block *sb)
{
return WRAPFS_SB(sb)->lower_sb;
}

//保存low level fs sb到wrapfs_sb_info数据结构
static inline void wrapfs_set_lower_super(struct super_block *sb,
 struct super_block *val)
{
WRAPFS_SB(sb)->lower_sb = val;
}

//path_get : 从wrapfs_dentry_info成员lower_path获取保存的low level fs path结构数据，　

//必须与 wrapfs_put_lower_path成对调用，即进行path_puth

static inline void wrapfs_get_lower_path(const struct dentry *dent,
struct path *lower_path)
{
spin_lock(&WRAPFS_D(dent)->lock);
pathcpy(lower_path, &WRAPFS_D(dent)->lower_path);
path_get(lower_path);
spin_unlock(&WRAPFS_D(dent)->lock);
return;
}
static inline void wrapfs_put_lower_path(const struct dentry *dent,
struct path *lower_path)
{
path_put(lower_path);
return;
}

//保存low level fs path结构数据到wrapfs_dentry_info的lower_path成员
static inline void wrapfs_set_lower_path(const struct dentry *dent,
struct path *lower_path)
{
spin_lock(&WRAPFS_D(dent)->lock);
pathcpy(&WRAPFS_D(dent)->lower_path, lower_path);
spin_unlock(&WRAPFS_D(dent)->lock);
return;
}