割り込みの後半部、ファイルシステム

$ grep cd /etc/auto.misc 
cd              -fstype=iso9660,ro,nosuid,nodev :/dev/cdrom
$ 

◆stat()システム・コールとstatコマンド

STAT(2)                    Linux Programmer's Manual                   STAT(2)
...
       int stat(const char *path, struct stat *buf);
...
          struct stat {
              dev_t     st_dev;     /* ID of device containing file */
              ino_t     st_ino;     /* inode number */
              mode_t    st_mode;    /* protection */
              nlink_t   st_nlink;   /* number of hard links */
              uid_t     st_uid;     /* user ID of owner */
              gid_t     st_gid;     /* group ID of owner */
              dev_t     st_rdev;    /* device ID (if special file) */
              off_t     st_size;    /* total size, in bytes */
              blksize_t st_blksize; /* blocksize for filesystem I/O */
              blkcnt_t  st_blocks;  /* number of blocks allocated */
              time_t    st_atime;   /* time of last access */
              time_t    st_mtime;   /* time of last modification */
              time_t    st_ctime;   /* time of last status change */
          };

$ stat .bashrc 
  File: .bashrc
  Size: 181       	Blocks: 9          IO Block: 1048576 regular file
Device: 38h/56d	Inode: 28759903    Links: 1
Access: (0644/-rw-r--r--)  Uid: ( 1013/     yas)   Gid: ( 5510/    prof)
Access: 2024-02-01 22:12:30.143693000 +0900
Modify: 2023-05-16 14:42:05.705198901 +0900
Change: 2023-05-16 14:42:05.705198901 +0900
 Birth: -
$ 

■VFSのオブジェクト

• struct file, struct file_operations: 開いたファイル。シーク・ポイ ンタは別。
• struct dentry, struct dentry_operations: directory entry。ファイル の名前。
• struct inode, struct inode_operations: ファイル。開いていないもの も含む。
• struct super_block, struct super_operations: スーパーブロック（マ ウントされたファイルシステム）

図? スーパーブロック、inode、dentry、file

◆struct file

    int fd1 = open("file1",O_RDONLY);
    int fd2 = open("file1",O_RDONLY);

ディスク上には対応するデータ構造は存在しない。

linux-6.6.9/include/linux/fs.h
 992:	struct file {
...
1004:	        fmode_t                 f_mode;
1005:	        atomic_long_t           f_count;
...
1007:	        loff_t                  f_pos;
...
1012:	        struct path             f_path;
1013:	        struct inode            *f_inode;       /* cached value */
1014:	        const struct file_operations    *f_op;
...
1021:	        void                    *private_data;
...
1027:	        struct address_space    *f_mapping;
...
1030:	} __randomize_layout
1031:	  __attribute__((aligned(4)));  /* lest something weird decides that 2 is OK */

linux-6.6.9/include/linux/path.h
   8:	struct path {
   9:	        struct vfsmount *mnt;
  10:	        struct dentry *dentry;
  11:	} __randomize_layout;

• f_path.dentry: 対応する dentry オブジェクトへのポインタ。
• f_mode: open() システム・コールのモードを少し変形したもの。 FMODE_READ, FMODE_WRITE 等。
• f_pos: ファイルを読み書きする位置。シークポインタ。
• f_count: 参照カウンタ。ファイルを開くと増える。fork() すると 増える。 close() すると減る。
• f_mapping: ファイルの内容をプロセスのアドレス空間にマップする時に 使う(ページキャッシュ)。
• private_data: ファイルシステムに固有のデータを保存する。 （継承、委譲の一実装方法。構造体を拡張する方法もある。）

◆継承・委譲の実装方法

図? 方法１

図? 方法２

図? 方法３

◆struct file_operations

struct fileの操作は、たとえば次のような形で行われる。 第1引数は、struct file *。

    struct file *file;
    file->f_op->read(file, buf, count, pos);

再掲

linux-6.6.9/include/linux/fs.h
1852:	struct file_operations {
1853:	        struct module *owner;
1854:	        loff_t (*llseek) (struct file *, loff_t, int);
1855:	        ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
1856:	        ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
1857:	        ssize_t (*read_iter) (struct kiocb *, struct iov_iter *);
1858:	        ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);
1859:	        int (*iopoll)(struct kiocb *kiocb, struct io_comp_batch *,
1860:	                        unsigned int flags);
1861:	        int (*iterate_shared) (struct file *, struct dir_context *);
1862:	        __poll_t (*poll) (struct file *, struct poll_table_struct *);
1863:	        long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
1864:	        long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
1865:	        int (*mmap) (struct file *, struct vm_area_struct *);
1866:	        unsigned long mmap_supported_flags;
1867:	        int (*open) (struct inode *, struct file *);
1868:	        int (*flush) (struct file *, fl_owner_t id);
1869:	        int (*release) (struct inode *, struct file *);
1870:	        int (*fsync) (struct file *, loff_t, loff_t, int datasync);
1871:	        int (*fasync) (int, struct file *, int);
1872:	        int (*lock) (struct file *, int, struct file_lock *);
1873:	        unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
1874:	        int (*check_flags)(int);
1875:	        int (*flock) (struct file *, int, struct file_lock *);
1876:	        ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
1877:	        ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
1878:	        void (*splice_eof)(struct file *file);
1879:	        int (*setlease)(struct file *, int, struct file_lock **, void **);
1880:	        long (*fallocate)(struct file *file, int mode, loff_t offset,
1881:	                          loff_t len);
1882:	        void (*show_fdinfo)(struct seq_file *m, struct file *f);
1883:	#ifndef CONFIG_MMU
1884:	        unsigned (*mmap_capabilities)(struct file *);
1885:	#endif
1886:	        ssize_t (*copy_file_range)(struct file *, loff_t, struct file *,
1887:	                        loff_t, size_t, unsigned int);
1888:	        loff_t (*remap_file_range)(struct file *file_in, loff_t pos_in,
1889:	                                   struct file *file_out, loff_t pos_out,
1890:	                                   loff_t len, unsigned int remap_flags);
1891:	        int (*fadvise)(struct file *, loff_t, loff_t, int);
1892:	        int (*uring_cmd)(struct io_uring_cmd *ioucmd, unsigned int issue_flags);
1893:	        int (*uring_cmd_iopoll)(struct io_uring_cmd *, struct io_comp_batch *,
1894:	                                unsigned int poll_flags);
1895:	} __randomize_layout;

• 多くは同名のシステム・コールを実装するために使われる。

◆struct dentry (directory entry)

linux-6.6.9/include/linux/dcache.h
  82:	struct dentry {
...
  87:	        struct dentry *d_parent;        /* parent directory */
  88:	        struct qstr d_name;
  89:	        struct inode *d_inode;          /* Where the name belongs to - NULL is
  90:	                                         * negative */
  91:	        unsigned char d_iname[DNAME_INLINE_LEN];        /* small names */
...
  94:	        struct lockref d_lockref;       /* per-dentry lock and refcount */
  95:	        const struct dentry_operations *d_op;
  96:	        struct super_block *d_sb;       /* The root of the dentry tree */
...
  98:	        void *d_fsdata;                 /* fs-specific data */
...
 104:	        struct list_head d_child;       /* child of parent list */
 105:	        struct list_head d_subdirs;     /* our children */
...
 114:	} __randomize_layout;

 283:	static inline unsigned d_count(const struct dentry *dentry)
 284:	{
 285:	        return dentry->d_lockref.count;
 286:	}

  35:	 #define HASH_LEN_DECLARE u32 hash; u32 len

  49:	struct qstr {
  50:	        union {
  51:	                struct {
  52:	                        HASH_LEN_DECLARE;
  53:	                };
  54:	                u64 hash_len;
  55:	        };
  56:	        const unsigned char *name;
  57:	};

  71:	# define DNAME_INLINE_LEN 32 /* 192 bytes */

• d_inode: この dentry に対応している inode 。NULL なら対応している ものがない(ネガティブキャッシュ)。
• d_name, d_iname[]: 文字列の名前を保持する。 短いもの(DNAME_INLINE_LEN-1以下)は、dentry 構造体中の d_iname[] に入れる。長いものは、 別の場所にメモリを確保して保存する。
• d_lockref.count: 参照カウンタ。
• d_op: dentry を操作するための手続き。
• d_sb: superblock へのポインタ
• d_parent: その dentry を含んでいるディレクトリの dentry 。たとえば、 /home/yas というパス名で、yas の d_parent は、home の dentry を指す。 home の dentry は、/ の dentry を指す。
• d_child: 共通の d_parent に含まれている d_entry をつなぐ。
• d_subdirs: 自分自身の子供のディレクトリ
• d_fsdata: ファイルシステム固有のデータ。

◆dentryの状態

• 使用中: count が 1 以上。有効なinodeを保持。
• 空き: count が 0。有効なinodeを保持。キャッシュとしてメモリ中に存在する。 同じファイルを再び open() した時に高速。 メモリが不足してきたら消されることがある>
• ネガティブ・キャッシュ: count が負。有効な inode を保持していない。 ファイルが削除されたか、存在しないファイルを open() しようとした時にそ のような dentry が作られる。 存在しないファイルを繰り返し open() した時にディスクに行かなくてもエラー ENOENT が返せる(ネガティブ・キャッシュ)。

◆struct inode

linux-6.6.9/include/linux/fs.h
 639:	struct inode {
 640:	        umode_t                 i_mode;
 641:	        unsigned short          i_opflags;
 642:	        kuid_t                  i_uid;
 643:	        kgid_t                  i_gid;
...
 651:	        const struct inode_operations   *i_op;
 652:	        struct super_block      *i_sb;
...
 660:	        unsigned long           i_ino;
...
 669:	                const unsigned int i_nlink;
...
 672:	        dev_t                   i_rdev;
 673:	        loff_t                  i_size;
 674:	        struct timespec64       i_atime;
 675:	        struct timespec64       i_mtime;
 676:	        struct timespec64       __i_ctime; /* use inode_*_ctime accessors! */
 677:	        spinlock_t              i_lock; /* i_blocks, i_bytes, maybe i_size */
 678:	        unsigned short          i_bytes;
 679:	        u8                      i_blkbits;
 680:	        u8                      i_write_hint;
 681:	        blkcnt_t                i_blocks;
...
 694:	        struct hlist_node       i_hash;
...
 708:	                struct hlist_head       i_dentry;
...
 713:	        atomic_t                i_count;
...
 748:	        void                    *i_private; /* fs or device private pointer */
 749:	} __randomize_layout;

• i_ino: inode番号。ファイルシステムでユニーク。
• i_uid, i_gid, i_nlink, i_uid, i_gid, i_rdev, i_blkbits, i_size, i_atime, i_mtime, i_ctime, i_blocks, i_bytes, i_mode: 属性。stat() システム・コー ルで返される。ls -l で表示される。
• i_op: そのinodeに固有の手続きのリスト。後述
• i_sb: 属しているファイルシステムの superblock へのポインタ。
• i_state: inodeの状態(dirty かどうか、ディスクへの 書き込みを行っているかどうか、等)を表す。
• i_hash: ファイルを開くことの高速のためのハッシュ表を作るためのフィー ルド。　
• i_dentry: そのinodeを含んでいる dentry 構造体のリスト。
• i_count: 参照カウンタ。0 が未使用の意味。

◆struct inode_operations

    struct inode *inode;
    ...
    inode->i_op->create(idmap, inode, name, mode, true);

1904:	struct inode_operations {
1905:	        struct dentry * (*lookup) (struct inode *,struct dentry *, unsigned int);
1906:	        const char * (*get_link) (struct dentry *, struct inode *, struct delayed_call *);
1907:	        int (*permission) (struct mnt_idmap *, struct inode *, int);
1908:	        struct posix_acl * (*get_inode_acl)(struct inode *, int, bool);
1909:	
1910:	        int (*readlink) (struct dentry *, char __user *,int);
1911:	
1912:	        int (*create) (struct mnt_idmap *, struct inode *,struct dentry *,
1913:	                       umode_t, bool);
1914:	        int (*link) (struct dentry *,struct inode *,struct dentry *);
1915:	        int (*unlink) (struct inode *,struct dentry *);
1916:	        int (*symlink) (struct mnt_idmap *, struct inode *,struct dentry *,
1917:	                        const char *);
1918:	        int (*mkdir) (struct mnt_idmap *, struct inode *,struct dentry *,
1919:	                      umode_t);
1920:	        int (*rmdir) (struct inode *,struct dentry *);
1921:	        int (*mknod) (struct mnt_idmap *, struct inode *,struct dentry *,
1922:	                      umode_t,dev_t);
1923:	        int (*rename) (struct mnt_idmap *, struct inode *, struct dentry *,
1924:	                        struct inode *, struct dentry *, unsigned int);
1925:	        int (*setattr) (struct mnt_idmap *, struct dentry *, struct iattr *);
1926:	        int (*getattr) (struct mnt_idmap *, const struct path *,
1927:	                        struct kstat *, u32, unsigned int);
1928:	        ssize_t (*listxattr) (struct dentry *, char *, size_t);
1929:	        int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64 start,
1930:	                      u64 len);
1931:	        int (*update_time)(struct inode *, int);
1932:	        int (*atomic_open)(struct inode *, struct dentry *,
1933:	                           struct file *, unsigned open_flag,
1934:	                           umode_t create_mode);
1935:	        int (*tmpfile) (struct mnt_idmap *, struct inode *,
1936:	                        struct file *, umode_t);
1937:	        struct posix_acl *(*get_acl)(struct mnt_idmap *, struct dentry *,
1938:	                                     int);
1939:	        int (*set_acl)(struct mnt_idmap *, struct dentry *,
1940:	                       struct posix_acl *, int);
1941:	        int (*fileattr_set)(struct mnt_idmap *idmap,
1942:	                            struct dentry *dentry, struct fileattr *fa);
1943:	        int (*fileattr_get)(struct dentry *dentry, struct fileattr *fa);
1944:	        struct offset_ctx *(*get_offset_ctx)(struct inode *inode);
1945:	} ____cacheline_aligned;

• 多くのものは、同名のシステム・コールと関連している。
• 引数によく現れる struct mnt_idmap * の中身は、名前空間を表す構造 体 struct user_namespace * (と参照カウンタ)。名前空間が別だと、ルート ディレクトリを別に持てる。
• create(): open() システム・コールや creat() システム・コールで、ファ イルを作成する時に呼ばれる。引数は、ディレクトリの inode、そのディレク トリの中の名前を示す dentry、名前解決で使うデータ。
• lookup(): ファイル名を引数にするシステム・コールの実装で、 既存のファイルを探すのに使う。 存在しない時には、空の inode (ネガティブキャッシュ)が作られる。 存在しないファイルを繰り返し open() した時にすぐにエラーになる。
• get_link(): シンボリック・リンクをたどる操作で用いる。
• permission(), get_acl(), set_acl(): アクセス権のチェックで用いる。
• kstat, iattr, fileattr は属性。

◆struct super_block

linux-6.6.9/include/linux/fs.h
1188:	struct super_block {
...
1193:	        loff_t                  s_maxbytes;     /* Max file size */
...
1195:	        const struct super_operations   *s_op;
...
1237:	        void                    *s_fs_info;     /* Filesystem private info */
...
1301:	        struct list_lru         s_dentry_lru;
1302:	        struct list_lru         s_inode_lru;
...
1315:	        struct list_head        s_inodes;       /* all inodes */
...
1319:	} __randomize_layout;

• s_maxbytes: 作成できるファイルの大きさの最大。
• s_op: ファイルシステム固有の手続きのリスト。後述
• s_fs_info: ファイルシステムのインスタンス（マウントごとに異なる） に固有のデータ。インスタンス変数。
• s_root: どこにマウントしているかをしめすディレクトリ
• s_inodes, s_dentry_lru, s_inode_lru: ファイルシステムに含まれてい るinode や dentry を管理するためのフィールド。

◆struct super_operations

    struct super_block *sh;
    ...
    sh->s_op->write_super(sb);

linux-6.6.9/include/linux/fs.h
1995:	struct super_operations {
1996:	        struct inode *(*alloc_inode)(struct super_block *sb);
1997:	        void (*destroy_inode)(struct inode *);
1998:	        void (*free_inode)(struct inode *);
1999:	
2000:	        void (*dirty_inode) (struct inode *, int flags);
2001:	        int (*write_inode) (struct inode *, struct writeback_control *wbc);
2002:	        int (*drop_inode) (struct inode *);
2003:	        void (*evict_inode) (struct inode *);
2004:	        void (*put_super) (struct super_block *);
2005:	        int (*sync_fs)(struct super_block *sb, int wait);
2006:	        int (*freeze_super) (struct super_block *, enum freeze_holder who);
2007:	        int (*freeze_fs) (struct super_block *);
2008:	        int (*thaw_super) (struct super_block *, enum freeze_holder who);
2009:	        int (*unfreeze_fs) (struct super_block *);
2010:	        int (*statfs) (struct dentry *, struct kstatfs *);
2011:	        int (*remount_fs) (struct super_block *, int *, char *);
2012:	        void (*umount_begin) (struct super_block *);
2013:	
2014:	        int (*show_options)(struct seq_file *, struct dentry *);
2015:	        int (*show_devname)(struct seq_file *, struct dentry *);
2016:	        int (*show_path)(struct seq_file *, struct dentry *);
2017:	        int (*show_stats)(struct seq_file *, struct dentry *);
2018:	#ifdef CONFIG_QUOTA
2019:	        ssize_t (*quota_read)(struct super_block *, int, char *, size_t, loff_t);
2020:	        ssize_t (*quota_write)(struct super_block *, int, const char *, size_t, loff_t);
2021:	        struct dquot **(*get_dquots)(struct inode *);
2022:	#endif
2023:	        long (*nr_cached_objects)(struct super_block *,
2024:	                                  struct shrink_control *);
2025:	        long (*free_cached_objects)(struct super_block *,
2026:	                                    struct shrink_control *);
2027:	        void (*shutdown)(struct super_block *sb);
2028:	};

• alloc_inode: そのファイルシステム内に inode 構造体を確保する。
• destroy_inode: メモリ中の inode 構造体を free する。
• dirty_inode: inode が dirty である(データの変更を行った)ことを伝える。
• write_inode: inode をディスクへ書く。
• put_super: マウントを解除(アンマウント)の時に、その構造体が参照さ れなくなったことを通知する。
• sync_fs: 更新されたスーパーブロックをディスクへ書き出す。
• freeze_fs, unfreeze_fs: ファイルシステムの変更を一時的に禁止する／ 禁止を解除する。LVM (Logical Volume Manager) で使う。
• statfs: 統計情報(空き容量、inode数等)を返す。
• remount_fs: マウントしなおす（オプションを変更する。例: ro (read-only)からrw (read-write) へ。）

◆task_struct と struct file

linux-6.6.9/include/linux/sched.h
 743:	struct task_struct {
...
1094:	        struct files_struct             *files;
...
1554:	};

linux-6.6.9/include/linux/fdtable.h
  24:	#define NR_OPEN_DEFAULT BITS_PER_LONG

  49:	struct files_struct {
...
  57:	        struct fdtable __rcu *fdt;
  58:	        struct fdtable fdtab;
...
  67:	        struct file __rcu * fd_array[NR_OPEN_DEFAULT];
  68:	};

  27:	struct fdtable {
...
  29:	        struct file __rcu **fd;      /* current fd array */
...
  34:	};

linux-6.6.9/include/asm-generic/bitsperlong.h
   8:	#ifdef CONFIG_64BIT
   9:	#define BITS_PER_LONG 64
  10:	#else
  11:	#define BITS_PER_LONG 32
  12:	#endif /* CONFIG_64BIT */

図? task_struct、ファイル記述子、file構造体、その他

■read() システムコールと Ext4 ファイルシステム

◆read() システム・コール

linux-6.6.9/fs/read_write.c
 621:	SYSCALL_DEFINE3(read, unsigned int, fd, char __user *, buf, size_t, count)
 622:	{
 623:	        return ksys_read(fd, buf, count);
 624:	}

 602:	ssize_t ksys_read(unsigned int fd, char __user *buf, size_t count)
 603:	{
 604:	        struct fd f = fdget_pos(fd);
 605:	        ssize_t ret = -EBADF;
 606:	
 607:	        if (f.file) {
 608:	                loff_t pos, *ppos = file_ppos(f.file);
 609:	                if (ppos) {
 610:	                        pos = *ppos;
 611:	                        ppos = &pos;
 612:	                }
 613:	                ret = vfs_read(f.file, buf, count, ppos);
 614:	                if (ret >= 0 && ppos)
 615:	                        f.file->f_pos = pos;
 616:	                fdput_pos(f);
 617:	        }
 618:	        return ret;
 619:	}

linux-6.6.9/include/linux/file.h
  36:	struct fd {
  37:	        struct file *file;
  38:	        unsigned int flags;
  39:	};

• fdget_pos() で、fd (int型) から struct file * を含む struct fd へ変換する。 内部的には、current->files->fd_array[fd] とだいたい同じ。 さらに、pos を操作するためのロックも取得している。
• file_ppos() で、現在の読み書きする位置 pos へのポインタを得、さらに、その 内容をローカル変数に pos にコピーする。
• vfs_read() という VFS 層の手続きを呼び出して、実際にデータを読み込む。
• struct file の中にある pos を更新する。
• fdput_pos() で、pos を操作するためのロックを開放している。

◆vfs_read()

linux-6.6.9/fs/read_write.c
 450:	ssize_t vfs_read(struct file *file, char __user *buf, size_t count, loff_t *pos)
 451:	{
 452:	        ssize_t ret;
 453:	
 454:	        if (!(file->f_mode & FMODE_READ))
 455:	                return -EBADF;
 456:	        if (!(file->f_mode & FMODE_CAN_READ))
 457:	                return -EINVAL;
 458:	        if (unlikely(!access_ok(buf, count)))
 459:	                return -EFAULT;
 460:	
 461:	        ret = rw_verify_area(READ, file, pos, count);
 462:	        if (ret)
 463:	                return ret;
 464:	        if (count > MAX_RW_COUNT)
 465:	                count =  MAX_RW_COUNT;
 466:	
 467:	        if (file->f_op->read)
 468:	                ret = file->f_op->read(file, buf, count, pos);
 469:	        else if (file->f_op->read_iter)
 470:	                ret = new_sync_read(file, buf, count, pos);
 471:	        else
 472:	                ret = -EINVAL;
 473:	        if (ret > 0) {
 474:	                fsnotify_access(file);
 475:	                add_rchar(current, ret);
 476:	        }
 477:	        inc_syscr(current);
 478:	        return ret;
 479:	}

 379:	static ssize_t new_sync_read(struct file *filp, char __user *buf, size_t len, loff_t *ppos)
 380:	{
 381:	        struct kiocb kiocb;
 382:	        struct iov_iter iter;
 383:	        ssize_t ret;
 384:	
 385:	        init_sync_kiocb(&kiocb, filp);
 386:	        kiocb.ki_pos = (ppos ? *ppos : 0);
 387:	        iov_iter_ubuf(&iter, ITER_DEST, buf, len);
 388:	
 389:	        ret = call_read_iter(filp, &kiocb, &iter);
 390:	        BUG_ON(ret == -EIOCBQUEUED);
 391:	        if (ppos)
 392:	                *ppos = kiocb.ki_pos;
 393:	        return ret;
 394:	}

linux-6.6.9/include/linux/fs.h
1947:	static inline ssize_t call_read_iter(struct file *file, struct kiocb *kio,
1948:	                                     struct iov_iter *iter)
1949:	{
1950:	        return file->f_op->read_iter(kio, iter);
1951:	}

• file->f_modeを調べ、 ファイルが読み出しで open() されていなけければ()、エラー。
• access_ok() で、結果を保存するメモリ(buf, count)が書き込みできない とエラー。ファイルからすると、read() だが、メモリからすると書き込み。
• rw_verify_area() で、ファイルのその場所(posからpos+countまで)が存 在するかを確認する。
• __vfs_read() は、file構造体の操作で file->f_op->read といった手続きが存在すれば、それを呼び出す。
• __vfs_read() は、file構造体の操作で file->f_op->read_iter といった手続きが存在すれば、new_sync_read() を呼び出す。
• new_sync_read() は、call_read_iter() を呼ぶ。これは、 file->f_op->read_iter() を呼ぶ。

◆Ext4 の file_operations

linux-6.6.9/fs/ext4/file.c
 931:	const struct file_operations ext4_file_operations = {
 932:	        .llseek         = ext4_llseek,
 933:	        .read_iter      = ext4_file_read_iter,
 934:	        .write_iter     = ext4_file_write_iter,
 935:	        .iopoll         = iocb_bio_iopoll,
 936:	        .unlocked_ioctl = ext4_ioctl,
 937:	#ifdef CONFIG_COMPAT
 938:	        .compat_ioctl   = ext4_compat_ioctl,
 939:	#endif
 940:	        .mmap           = ext4_file_mmap,
 941:	        .mmap_supported_flags = MAP_SYNC,
 942:	        .open           = ext4_file_open,
 943:	        .release        = ext4_release_file,
 944:	        .fsync          = ext4_sync_file,
 945:	        .get_unmapped_area = thp_get_unmapped_area,
 946:	        .splice_read    = ext4_file_splice_read,
 947:	        .splice_write   = iter_file_splice_write,
 948:	        .fallocate      = ext4_fallocate,
 949:	};
 950:	
 951:	const struct inode_operations ext4_file_inode_operations = {
 952:	        .setattr        = ext4_setattr,
 953:	        .getattr        = ext4_file_getattr,
...
 960:	};

linux-6.6.9/fs/ext4/super.c
1627:	static const struct super_operations ext4_sops = {
1628:	        .alloc_inode    = ext4_alloc_inode,
1629:	        .free_inode     = ext4_free_in_core_inode,
...
1647:	};

• file_operations 構造体の関数のうち、14 個を定義している。
• 主な操作は、read, write, ioctl, mmap, open, release, fsync。
• generic_ から始まるもの は、継承／委譲。iocb_bio_iopoll(), iter_file_splice_write() も、他のファイルシステムと共通。ext4 固有では ない。
• inode の操作、ext4_file_inode_operations もある。
• スーパーブロックの操作、ext4_sops もある。
• dentry の操作で特別な操作を行うための struct dentry_operations は、 ext4 では定義されていない。　

◆Ext4 の inode

linux-6.6.9/fs/ext4/ext4.h
 992:	struct ext4_inode_info {
...
1081:	        struct inode vfs_inode;
...
1156:	};

1749:	static inline struct ext4_inode_info *EXT4_I(struct inode *inode)
1750:	{
1751:	        return container_of(inode, struct ext4_inode_info, vfs_inode);
1752:	}

• Ext4 独自の構造体 struct ext4_inode_info の内部には、Linux 標準の struct inode がある。
• 標準の struct inode から Ext4 独自の struct ext4_inode_info を取り出すには、 EXT4_I() を用いる。
• EXT4_I() は、 container_of() マクロを使っている。
• container_of() は、当該メンバのオフセットを引き算して、外側の構造 体の番地を求めている。

図? Ext4 ファイルシステムで使う構造体 ext4_inode_info での struct inode の保持

◆Ext4のext4_file_read_iter()

linux-6.6.9/fs/ext4/file.c
 130:	static ssize_t ext4_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
 131:	{
...
 147:	        return generic_file_read_iter(iocb, to);
 148:	}

• ファイルの読み出しは、filp->f_op->read_iter() で実装されている。
• Ext4 では、read_iter() は、ext4_file_operations で定義されているように、 ext4_file_read_iter()。
• これは、Ext4 固有の処理が少しあるが、大部分の処理は 汎用の generic_file_read_iter() を呼んで実装している。

◆汎用のgeneric_file_read_iter()

linux-6.6.9/mm/filemap.c
2789:	ssize_t
2790:	generic_file_read_iter(struct kiocb *iocb, struct iov_iter *iter)
2791:	{
...
2831:	        return filemap_read(iocb, iter, retval);
2832:	}

• generic_file_read_iter() は、普通、generic_file_buffered_read() を呼ぶ。
• ファイルの入出力とメモリ管理が統合されている。入出力の実装は、mm/ 以下にあるファイルで実装されている。

◆汎用のfilemap_read()

linux-6.6.9/include/linux/mm_types.h
 293:	struct folio {
...
 323:	                struct page page;
...
 361:	};

linux-6.6.9/include/linux/pagevec.h
  28:	struct folio_batch {
  29:	        unsigned char nr;
  30:	        bool percpu_pvec_drained;
  31:	        struct folio *folios[PAGEVEC_SIZE];
  32:	};

linux-6.6.9/mm/filemap.c
2617:	ssize_t filemap_read(struct kiocb *iocb, struct iov_iter *iter,
2618:	                ssize_t already_read)
2619:	{
2620:	        struct file *filp = iocb->ki_filp;
2621:	        struct file_ra_state *ra = &filp->f_ra;
2622:	        struct address_space *mapping = filp->f_mapping;
2623:	        struct inode *inode = mapping->host;
2624:	        struct folio_batch fbatch;
2625:	        int i, error = 0;
2626:	        bool writably_mapped;
2627:	        loff_t isize, end_offset;
...
2636:	        folio_batch_init(&fbatch);
2637:	
2638:	        do {
...
2652:	                error = filemap_get_pages(iocb, iter->count, &fbatch, false);
...
2683:	                for (i = 0; i < folio_batch_count(&fbatch); i++) {
2684:	                        struct folio *folio = fbatch.folios[i];
...
2703:	                        copied = copy_folio_to_iter(folio, offset, bytes, iter);
2704:	
2705:	                        already_read += copied;
2706:	                        iocb->ki_pos += copied;
2707:	                        last_pos = iocb->ki_pos;
...
2713:	                }
...
2717:	                folio_batch_init(&fbatch);
2718:	        } while (iov_iter_count(iter) && iocb->ki_pos < isize && !error);
...
2722:	        return already_read ? already_read : error;
2723:	}

linux-6.6.9/include/linux/uio.h
 182:	static inline size_t copy_folio_to_iter(struct folio *folio, size_t offset,
 183:	                size_t bytes, struct iov_iter *i)
 184:	{
 185:	        return copy_page_to_iter(&folio->page, offset, bytes, i);
 186:	}

• filemap_read() は、filemap_get_pages() を呼び、ページ単位で ファイルのブロックを読む。
• filemap_get_pages() は、ファイルのブロックを読み、 struct page *page の配列 (folio_batch) に結果を返す。 struct page *page は、物理ページと 1 対 1 に対応する構造体。 1月13日の 物理メモリの管理 で出てきた。 ここからファイル入出力のページングが統合的に実装されていることがわかる。
• for 文の中では、ページ単位でファイルの内容をコピーしている。
• copy_page_to_iter() は、copy_to_user() と同様に、カーネルで管理し ている物理メモリ(struct page *page)からユーザ空間内のメモリ(iter)にコピー する。
• コピーできたら、ファイル中の読み書きする位置 pos や 読み込んだバイト数 already_read を更新する。
• already_read は、最後 read() システム・コールの返り値としても使われる。

■mkdir() システムコール

◆mkdir() システム・コール

linux-6.6.9/fs/namei.c
4162:	SYSCALL_DEFINE2(mkdir, const char __user *, pathname, umode_t, mode)
4163:	{
4164:	        return do_mkdirat(AT_FDCWD, getname(pathname), mode);
4165:	}

4157:	SYSCALL_DEFINE3(mkdirat, int, dfd, const char __user *, pathname, umode_t, mode)
4158:	{
4159:	        return do_mkdirat(dfd, getname(pathname), mode);
4160:	}
4161:	

4128:	int do_mkdirat(int dfd, struct filename *name, umode_t mode)
4129:	{
4130:	        struct dentry *dentry;
4131:	        struct path path;
4132:	        int error;
4133:	        unsigned int lookup_flags = LOOKUP_DIRECTORY;
4134:	
4135:	retry:
4136:	        dentry = filename_create(dfd, name, &path, lookup_flags);
...
4144:	                error = vfs_mkdir(mnt_idmap(path.mnt), path.dentry->d_inode,
4145:	                                  dentry, mode);
...
4153:	        putname(name);
4154:	        return error;
4155:	}

• namei は、name to inode で、名前から inode を取り出す意味。
• mkdir() システム・コールの実装は、 mkdirat() システム・コールとも共通の do_mkdirat() を呼ぶ。 mkdir() の起点は、カレントワーキングディレクトリ(AT_FDCWD)。 mkdirat() の起点は、ファイル記述子で指定した任意のディレクトリ。
• getname() は、ユーザ空間にあるファイル名を カーネル空間にコピーし、構造体 struct filename に納める。
• do_mkdirat() は、filename_create() で新しく作成するディレクトリの dentry を作る。 この時点では、ファイル名だけが設定された状態になっており、inode は割当てられていない。
• vfs_mkdir() を呼び出す。 引数は、名前空間(を含むstruct mnt_idmap *)、 親ディレクトリの inode、新しく作られるディレクトリの dentry、 新しく作られるディレクトリのパーミッション(rwxrwxrwx)を表す mode (unsigned short)。

◆vfs_mkdir()

linux-6.6.9/fs/namei.c
4100:	int vfs_mkdir(struct mnt_idmap *idmap, struct inode *dir,
4101:	              struct dentry *dentry, umode_t mode)
4102:	{
...
4110:	        if (!dir->i_op->mkdir)
4111:	                return -EPERM;
...
4121:	        error = dir->i_op->mkdir(idmap, dir, dentry, mode);
...
4124:	        return error;
4125:	}

• dir->i_op->mkdir()　という関数が存在しなければエラー。 たとえば、CD-ROM 等 mkdir() できない時は、存在しない。
• dir->i_op->mkdir()　という関数を呼ぶ。

■授業評価アンケート

アンケートはTwinsから回答してください。

なお、皆さんの評価が成績に影響することは一切ありません。 また、評価結果を教育の改善以外の目的に利用することはありませんし、 評価結果を公開する場合には個人を特定できるような情報は含めません。

2月26日までに回答して下さい。

■課題5 割り込みの後半部、ファイルシステム

★問題(501) Work Queueの初期化

void f(int arg1, int arg2) {
   省略;
}

static struct /*空欄(a)*/ wq1;

void work_queue_handler(struct work_struct *work) { /* Work Queue ハンドラ */
    int arg1, arg2;
    arg1 = 省略; /* f() の引数 */
    arg2 = 省略; /* f() の引数 */
    /*空欄(b)*/
}

初期化
{
	/*空欄(c)*/(&wq1, /*空欄(d)*/);
}

★問題(502) Work Queueハンドラの実行

irqreturn_t irq_handler(int irq, void *dev) {
    /*空欄(e)*/(/*空欄(f)*/);
    return IRQ_HANDLED;
}

★問題(503) struct fileの役割

★問題(504) Ext4ファイルシステム

このページで説明されている関数のうち、次のものを１つずつ上げなさい。

• VFS 層の関数:
• ファイルシステム Ext4 に固有の関数:

★問題(505) symlink()システムコール

2024/02/07 18:00訂正済み。空欄(i)が2つあったので、１つを空欄(j)にしました。

int vfs_symlink(struct mnt_idmap *idmap, struct inode *dir,
                struct dentry *dentry, const char *oldname)
{
        int error;
...
        if (!/*空欄(g)*/->i_op->/*空欄(h)*/)
                return -EPERM;
...
        error = /*空欄(g)*/->i_op->/*空欄(h)*/(idmap, /*空欄(i)*/, /*空欄(j)*/, /*省略*/);
...
        return error;
}

        error = /*空欄(g)*/->i_op->/*空欄(h)*/(idmap, /*空欄(j)*/, /*空欄(i)*/, /*省略*/);

★問題(506) 期末試験

• 日付:
• 曜日:
• 開始時刻:
• 持ち込めるもの: