KernelStudy.net

908 struct super_block {
909         struct list_head        s_list;         /* Keep this first */
910         dev_t                   s_dev;          /* search index; _not_ kdev_t */
911         unsigned long           s_blocksize;
912         unsigned char           s_blocksize_bits;
913         unsigned char           s_dirt;
914         unsigned long long      s_maxbytes;     /* Max file size */
915         struct file_system_type *s_type;
916         const struct super_operations   *s_op;
917         struct dquot_operations *dq_op;
918         struct quotactl_ops     *s_qcop;
919         struct export_operations *s_export_op;
920         unsigned long           s_flags;
921         unsigned long           s_magic;
922         struct dentry           *s_root;
923         struct rw_semaphore     s_umount;
924         struct mutex            s_lock;
925         int                     s_count;
926         int                     s_syncing;
927         int                     s_need_sync_fs;
928         atomic_t                s_active;
929 #ifdef CONFIG_SECURITY
930         void                    *s_security;
931 #endif
932         struct xattr_handler    **s_xattr;
933
934         struct list_head        s_inodes;       /* all inodes */
935         struct list_head        s_dirty;        /* dirty inodes */
936         struct list_head        s_io;           /* parked for writeback */
937         struct hlist_head       s_anon;         /* anonymous dentries for (nfs) exporting */
938         struct list_head        s_files;
939
940         struct block_device     *s_bdev;
941         struct mtd_info         *s_mtd;
942         struct list_head        s_instances;
943         struct quota_info       s_dquot;        /* Diskquota specific options */
944
945         int                     s_frozen;
946         wait_queue_head_t       s_wait_unfrozen;
947
948         char s_id[32];                          /* Informational name */
949
950         void                    *s_fs_info;     /* Filesystem private info */
951
952         /*
953          * The next field is for VFS *only*. No filesystems have any business
954          * even looking at it. You had been warned.
955          */
956         struct mutex s_vfs_rename_mutex;        /* Kludge */
957
958         /* Granularity of c/m/atime in ns.
959            Cannot be worse than a second */
960         u32                s_time_gran;
961
962         /*
963          * Filesystem subtype.  If non-empty the filesystem type field
964          * in /proc/mounts will be "type.subtype"
965          */
966         char *s_subtype;
967 };

<위치 : http://lxr.linux.no/source/include/linux/fs.h#L908>

1161 struct super_operations {
1162         struct inode *(*alloc_inode)(struct super_block *sb);
1163         void (*destroy_inode)(struct inode *);
1164
1165         void (*read_inode) (struct inode *);
1166  
1167         void (*dirty_inode) (struct inode *);
1168         int (*write_inode) (struct inode *, int);
1169         void (*put_inode) (struct inode *);
1170         void (*drop_inode) (struct inode *);
1171 void (*delete_inode) (struct inode *);
1172         void (*put_super) (struct super_block *);
1173         void (*write_super) (struct super_block *);
1174         int (*sync_fs)(struct super_block *sb, int wait);
1175         void (*write_super_lockfs) (struct super_block *);
1176         void (*unlockfs) (struct super_block *);
1177         int (*statfs) (struct dentry *, struct kstatfs *);
1178         int (*remount_fs) (struct super_block *, int *, char *);
1179         void (*clear_inode) (struct inode *);
1180         void (*umount_begin) (struct vfsmount *, int);
1181
1182         int (*show_options)(struct seq_file *, struct vfsmount *);
1183         int (*show_stats)(struct seq_file *, struct vfsmount *);
1184 #ifdef CONFIG_QUOTA
1185         ssize_t (*quota_read)(struct super_block *, int, char *, size_t, loff_t);
1186         ssize_t (*quota_write)(struct super_block *, int, const char *, size_t, loff_t);
1187 #endif
1188 };

<위치 : http://lxr.linux.no/source/include/linux/fs.h#L1161>

530 struct inode {
531         struct hlist_node       i_hash;
532         struct list_head        i_list;
533         struct list_head        i_sb_list;
534         struct list_head        i_dentry;
535         unsigned long           i_ino;
536         atomic_t                i_count;
537         unsigned int            i_nlink;
538         uid_t                   i_uid;
539         gid_t                   i_gid;
540         dev_t                   i_rdev;
541         unsigned long           i_version;
542         loff_t                  i_size;
543 #ifdef __NEED_I_SIZE_ORDERED
544         seqcount_t              i_size_seqcount;
545 #endif
546         struct timespec         i_atime;
547         struct timespec         i_mtime;
548         struct timespec         i_ctime;
549         unsigned int            i_blkbits;
550         blkcnt_t                i_blocks;
551         unsigned short          i_bytes;
552         umode_t                 i_mode;
553         spinlock_t              i_lock; /* i_blocks, i_bytes, maybe i_size */
554         struct mutex            i_mutex;
555         struct rw_semaphore     i_alloc_sem;
556         const struct inode_operations   *i_op;
557         const struct file_operations    *i_fop; /* former ->i_op->default_file_ops */
558         struct super_block      *i_sb;
559         struct file_lock        *i_flock;
560         struct address_space    *i_mapping;
561         struct address_space    i_data;
562 #ifdef CONFIG_QUOTA
563         struct dquot            *i_dquot[MAXQUOTAS];
564 #endif
565         struct list_head        i_devices;
566         union {
567                 struct pipe_inode_info  *i_pipe;
568                 struct block_device     *i_bdev;
569                 struct cdev             *i_cdev;
570         };
571         int                     i_cindex;
572
573         __u32                   i_generation;
574
575 #ifdef CONFIG_DNOTIFY
576         unsigned long           i_dnotify_mask; /* Directory notify events */
577         struct dnotify_struct   *i_dnotify; /* for directory notifications */
578 #endif
579
580 #ifdef CONFIG_INOTIFY
581         struct list_head        inotify_watches; /* watches on this inode */
582         struct mutex            inotify_mutex;  /* protects the watches list */
583 #endif
584
585         unsigned long           i_state;
586         unsigned long           dirtied_when;   /* jiffies of first dirtying */
587
588         unsigned int            i_flags;
589
590         atomic_t                i_writecount;
591 #ifdef CONFIG_SECURITY
592         void                    *i_security;
593 #endif
594         void                    *i_private; /* fs or device private pointer */
595 };

<위치 : http://lxr.linux.no/source/include/linux/fs.h#L530>

1118 struct inode_operations {
1119         int (*create) (struct inode *,struct dentry *,int, struct nameidata *);
1120         struct dentry * (*lookup) (struct inode *,struct dentry *, struct nameidata *);
1121         int (*link) (struct dentry *,struct inode *,struct dentry *);
1122         int (*unlink) (struct inode *,struct dentry *);
1123         int (*symlink) (struct inode *,struct dentry *,const char *);
1124         int (*mkdir) (struct inode *,struct dentry *,int);
1125         int (*rmdir) (struct inode *,struct dentry *);
1126         int (*mknod) (struct inode *,struct dentry *,int,dev_t);
1127 int (*rename) (struct inode *, struct dentry *,
1128 struct inode *, struct dentry *);
1129 int (*readlink) (struct dentry *, char __user *,int);
1130         void * (*follow_link) (struct dentry *, struct nameidata *);
1131 void (*put_link) (struct dentry *, struct nameidata *, void *);
1132         void (*truncate) (struct inode *);
1133         int (*permission) (struct inode *, int, struct nameidata *);
1134         int (*setattr) (struct dentry *, struct iattr *);
1135         int (*getattr) (struct vfsmount *mnt, struct dentry *, struct kstat *);
1136         int (*setxattr) (struct dentry *, const char *,const void *,size_t,int);
1137         ssize_t (*getxattr) (struct dentry *, const char *, void *, size_t);
1138         ssize_t (*listxattr) (struct dentry *, char *, size_t);
1139         int (*removexattr) (struct dentry *, const char *);
1140         void (*truncate_range)(struct inode *, loff_t, loff_t);
1141 };

<위치 : http://lxr.linux.no/source/include/linux/fs.h#L1118>

1088 struct file_operations {
1089 struct module *owner;
1090         loff_t (*llseek) (struct file *, loff_t, int);
1091         ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
1092         ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
1093         ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
1094         ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
1095         int (*readdir) (struct file *, void *, filldir_t);
1096         unsigned int (*poll) (struct file *, struct poll_table_struct *);
1097         int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);
1098         long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
1099         long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
1100         int (*mmap) (struct file *, struct vm_area_struct *);
1101         int (*open) (struct inode *, struct file *);
1102         int (*flush) (struct file *, fl_owner_t id);
1103         int (*release) (struct inode *, struct file *);
1104         int (*fsync) (struct file *, struct dentry *, int datasync);
1105         int (*aio_fsync) (struct kiocb *, int datasync);
1106         int (*fasync) (int, struct file *, int);
1107         int (*lock) (struct file *, int, struct file_lock *);
1108         ssize_t (*sendfile) (struct file *, loff_t *, size_t, read_actor_t, void *);
1109         ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
1110         unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
1111         int (*check_flags)(int);
1112         int (*dir_notify)(struct file *filp, unsigned long arg);
1113         int (*flock) (struct file *, int, struct file_lock *);
1114         ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
1115         ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
1116 };

<위치 : http://lxr.linux.no/source/include/linux/fs.h#L1088>

/**
 * Notes:
 * Implementing a small filesystem having one file
 *
 * -> What happens when we mount a file system?
 * -> What do we need to provide to the kernel so that we are mountable?
 * -> What inode, dentry and file operations do we have to support?
 */

#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/version.h>
#include <linux/fs.h>
#include <linux/sched.h>
#include <linux/statfs.h>
#include <linux/mm.h>
#include <asm/uaccess.h>
#include <asm/errno.h>
#include <linux/buffer_head.h>
#include <linux/pagemap.h> /* unlock_page */

#define RKFS_MAGIC 0xabcd
#define FILE_INODE_NUMBER 2

/* file_system_type */
/* get_sb */
static struct super_block *
rkfs_get_sb(struct file_system_type *, int, const char *, void *);
/* kill_sb */
static void
rkfs_kill_sb(struct super_block *);

/* super_operations */
/* read_inode */
static void
rkfs_super_read_inode(struct inode *inode);
/* write_inode */
static int
rkfs_super_write_inode(struct inode *inode, int sync);

/* inode_operations */
/* lookup */
static struct dentry *
rkfs_inode_lookup(struct inode *parent_inode, struct dentry *dentry, struct nameidata *);

/* file_operations */
static int
rkfs_file_open (struct inode *, struct file *);
/* readdir */
static int
rkfs_file_readdir(struct file *file, void *dirent, filldir_t filldir);
/* release */
static int
rkfs_file_release (struct inode *, struct file *);

/* Address Space Operations */
/* writepage */
static int
rkfs_writepage(struct page *page, struct writeback_control *wbc);
/* readpage */
static int
rkfs_readpage(struct file *file, struct page *page);
/* prepare_write */
static int
rkfs_prepare_write(struct file *file, struct page *page,
     unsigned from, unsigned to);
/* commit_write */
static int
rkfs_commit_write(struct file *file, struct page *page,
    unsigned from, unsigned to);

/* readpage */

/*
 * Data declarations
 */

static struct super_operations rkfs_sops = {
  read_inode: rkfs_super_read_inode,
  statfs: simple_statfs, /* handler from libfs */
  write_inode: &rkfs_super_write_inode
};

static struct inode_operations rkfs_iops = {
  lookup: rkfs_inode_lookup
};

static struct file_operations rkfs_fops = {
  open: rkfs_file_open,
  read: &generic_file_read,
  readdir: &rkfs_file_readdir,
  write: &generic_file_write,
  release: &rkfs_file_release,
  fsync: simple_sync_file
};

static struct file_system_type rkfs = {
  name:        "rkfs",
  get_sb:    rkfs_get_sb,
  kill_sb: rkfs_kill_sb,
  owner:        THIS_MODULE
};

static struct address_space_operations rkfs_aops = {
  .readpage = rkfs_readpage,
  .writepage = rkfs_writepage,
  .prepare_write = rkfs_prepare_write,
  .commit_write = rkfs_commit_write
};

static struct inode *rkfs_root_inode;

static char file_buf[PAGE_SIZE] = "Hello World\n";
static int file_size = 12;

/*
 * File-System Operations
 */

static int
rkfs_fill_super(struct super_block *sb, void *data, int silent)
{
  printk("RKFS: rkfs_fill_super\n" );
  sb->s_blocksize = 1024;
  sb->s_blocksize_bits = 10;
  sb->s_magic = RKFS_MAGIC;
  sb->s_op = &rkfs_sops; // super block operations
  sb->s_type = &rkfs; // file_system_type

  rkfs_root_inode = iget(sb, 1); // allocate an inode
  rkfs_root_inode->i_op = &rkfs_iops; // set the inode ops
  rkfs_root_inode->i_mode = S_IFDIR|S_IRWXU;
  rkfs_root_inode->i_fop = &rkfs_fops;

  if(!(sb->s_root = d_alloc_root(rkfs_root_inode))) {
    iput(rkfs_root_inode);
    return -ENOMEM;
  }

  return 0;
}

static struct super_block *
rkfs_get_sb(struct file_system_type *fs_type, int flags, const char *devname, void *data) {
  /* rkfs_fill_super this will be called to fill the superblock */
  return get_sb_single(
         fs_type,
         flags,
         data,
         &rkfs_fill_super);
}

static void
rkfs_kill_sb(struct super_block *super) {
  kill_anon_super(super);
}

/*
 * Super-Block Operations
 */

static void
rkfs_super_read_inode(struct inode *inode) {
  printk("RKFS: rkfs_super_read_inode\n");
  inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
  inode->i_mapping->a_ops = &rkfs_aops;
}

static int
rkfs_super_write_inode(struct inode *inode, int wait) {
  printk("RKFS: rkfs_super_write_inode (i_ino = %d) = %d\n",
  (int)inode->i_ino,
  (int)i_size_read(inode));
  if(inode->i_ino == FILE_INODE_NUMBER) {
    file_size = i_size_read(inode);
  }
  return 0;
}

/*
 * Inode Operations
 */

static char filename[] = "hello.txt";
static int filename_len = sizeof(filename) - 1;
static struct dentry *
rkfs_inode_lookup(struct inode *parent_inode, struct dentry *dentry, struct nameidata *nameidata) {
  struct inode *file_inode;
  printk("RKFS: rkfs_inode_lookup\n");
  if(parent_inode->i_ino != rkfs_root_inode->i_ino ||
     dentry->d_name.len != filename_len ||
     strncmp(dentry->d_name.name, filename, dentry->d_name.len)) {
    d_add(dentry, NULL);
    goto out;
  }

  file_inode = iget(parent_inode->i_sb, FILE_INODE_NUMBER);
  if(!file_inode)
    return ERR_PTR(-EACCES);
  file_inode->i_size = file_size;
  file_inode->i_mode = S_IFREG|S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH;
  file_inode->i_fop = &rkfs_fops;
  //  file_inode->i_fop
  d_add(dentry, file_inode);

 out:
  return NULL;
}

/*
 * File Operations
 */

static int
rkfs_file_open(struct inode *inode, struct file *file) {
  printk("RKFS: @rkfs_file_open max_readahead = %d (size = %d)\n", (int)file->f_ra.ra_pages, file_size);
  file->f_ra.ra_pages = 0; /* No read-ahead */
  return generic_file_open(inode, file);
}

static int
rkfs_file_release (struct inode *ino, struct file *file) {
  struct dentry *dentry;
  dentry = file->f_dentry;
  return 0;
}

static int
rkfs_file_readdir(struct file *file, void *dirent, filldir_t filldir) {
  struct dentry *de = file->f_dentry;

  if(file->f_pos > 2)
    return 1;
  if(filldir(dirent, ".", 1, file->f_pos++, de->d_inode->i_ino, DT_DIR))
    return 0;
  if(filldir(dirent, "..", 2, file->f_pos++, de->d_parent->d_inode->i_ino, DT_DIR))
    return 0;
  if(filldir(dirent, filename, filename_len, file->f_pos++, FILE_INODE_NUMBER, DT_REG))
    return 0;
  return 1;
}

/* address_space_operations */
static int
rkfs_writepage(struct page *page, struct writeback_control *wbc) {
  void *page_addr = kmap(page);
  printk("[RKFS] offset = %d\n", (int)page->index);
  printk("RKFS: WritePage: [%s] [%s] [%s] [%s]\n",
  PageUptodate(page) ? "Uptodate" : "Not Uptodate",
  PageDirty(page) ? "Dirty" : "Not Dirty",
  PageWriteback(page) ? "PageWriteback Set" : "PageWriteback Cleared",
  PageLocked(page) ? "Locked" : "Unlocked");
  memcpy(file_buf, page_addr, PAGE_SIZE);
  ClearPageDirty(page);
  if(PageLocked(page))
    unlock_page(page);
  kunmap(page);
  return 0;
}

static int
rkfs_readpage(struct file *file, struct page *page) {
  void *page_addr;
  printk("RKFS: readpage called for page index=[%d]\n", (int)page->index);
  if(page->index > 0) {
    return -ENOSPC;
  }

  printk("RKFS: Page: [%s] [%s] [%s] [%s]\n",
  PageUptodate(page) ? "Uptodate" : "Not Uptodate",
  PageDirty(page) ? "Dirty" : "Not Dirty",
  PageWriteback(page) ? "PageWriteback Set" : "PageWriteback Cleared",
  PageLocked(page) ? "Locked" : "Unlocked");
  SetPageUptodate(page);
  page_addr = kmap(page);
  if(page_addr)
   memcpy(page_addr, file_buf, PAGE_SIZE);
  if(PageLocked(page))
    unlock_page(page);
  kunmap(page);
  return 0;
}

static int
rkfs_prepare_write(struct file *file, struct page *page,
     unsigned from, unsigned to) {
  return 0;
}

/* modified from generic_commit_write. generic_commit_write calls the
 * block device layer to write set up buffer heads for I/O.
 */
static int
rkfs_commit_write(struct file *file, struct page *page,
    unsigned from, unsigned to) {
  struct inode *inode = page->mapping->host;
  void *page_addr = kmap(page);
  loff_t pos = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;

  printk("RKFS: commit_write: [%s] [%s] [%s] \n",
  PageUptodate(page) ? "Uptodate" : "Not Uptodate",
  PageDirty(page) ? "Dirty" : "Not Dirty",
  PageLocked(page) ? "Locked" : "Unlocked");

  if(page->index == 0) {
    memcpy(file_buf, page_addr, PAGE_SIZE);
    ClearPageDirty(page);
  }

  SetPageUptodate(page);
  kunmap(page);
  
  /*
   * No need to use i_size_read() here, the i_size
   * cannot change under us because we hold i_sem.
   */
  if (pos > inode->i_size) {
    i_size_write(inode, pos);
    mark_inode_dirty(inode);
  }

  
  return 0;
}

static int
rkfs_init_module(void) {
  int err;

  err = register_filesystem(&rkfs);
  return err;
}

static void
rkfs_cleanup_module(void) {
  unregister_filesystem(&rkfs);
}

module_init(rkfs_init_module);
module_exit(rkfs_cleanup_module);

MODULE_LICENSE("GPL");