Linux仮想ファイルシステムの4つの主要オブジェクト（スーパーブロック、inode、dentry、ファイル）の関係

  [[378977]]

1. ファイルシステム

1. ファイルシステムとは何ですか?

ファイル情報の管理と保存を担当するオペレーティング システム内のソフトウェア構成は、ファイル管理システム、または略してファイル システムと呼ばれます。

通常、ファイル システムは、ファイルを簡単に検索およびアクセスできるようにファイルを保存および整理するためのメカニズムです。

ファイル システムは、ファイル ストレージ デバイス上のスペースを整理して割り当て、ファイルの保存と、保存されたファイルの保護および取得を担当するシステムです。

ユーザーのファイルの作成、ファイルの保存、読み取り、変更、ダンプ、ファイル アクセスの制御、ユーザーが使用しなくなったファイルの取り消しなどを担当します。

ファイルの種類が増えるにつれて、さまざまなファイル システムを統一的に管理および整理するために、さらに多くのファイル システムが追加されます。

2. Linux ファイルシステム

Linux では、次の図に示すように、ファイル システムを VFS (仮想ファイル システム) と特定のファイル システムの 2 つのレイヤーに分割します。

仮想通貨

VFS (Virtual Filesystem Switch) は、仮想ファイルシステムまたは仮想ファイルシステムスイッチと呼ばれます。これはカーネル ソフトウェア レイヤーであり、特定のファイル システムの上にある抽象レイヤーであり、Posix ファイル システムに関連するすべての呼び出しを処理するために使用されます。さまざまなファイル システムに共通のインターフェイスを提供できるため、上位レベルのアプリケーションは共通のインターフェイスを使用してさまざまなファイル システムにアクセスできるようになります。また、異なるファイル システム間の通信のための媒体も提供します。

VFS は実際のファイルシステムではありません。メモリ内にのみ存在し、外部ストレージスペースには存在しません。 VFS はシステムの起動時に作成され、システムのシャットダウン時に消えます。

VFS は、スーパーブロック、inode、dentry、vfsmount などの構造で構成されています。

Linux システムには、一般的な **ext2、ext3、ext4、sysfs、rootfs、proc...** など、多くのファイル システムが存在します。

2. VFS

1. LinuxアーキテクチャにおけるVFSの位置づけ

ユーザーの観点から見ると、Linux のファイル システムは主に 3 つの層に分かれています。

• 1. 上位ファイルシステムのシステムコール（システムコール）
• 2. 仮想ファイルシステムVFS（仮想ファイルシステム）層、
• 3. VFS にマウントされたさまざまな実際のファイル システム。

Linux システム全体における VFS のアーキテクチャ上のビューは次のとおりです。

仮想通貨

Linux システムのユーザーは、アプリケーションのランタイム ライブラリとして GLIBC (POSIX 標準、GUN C ランタイム ライブラリ) を使用し、オペレーティング システムを通じてそれをシステム コール SCI (システム コール インターフェイス) に変換します。 SCI は、オペレーティング システム カーネルによって定義されたシステム コール インターフェイスです。この抽象化レイヤーにより、ユーザー プログラムの I/O 操作をカーネル インターフェイス呼び出しに変換できるようになります。

2. ユーザーはどのようにしてファイルを透過的に処理できますか?

各ファイルシステムは独立しており、独自の構成と操作方法を持っていることがわかります。ユーザーがすべてのファイル システムを理解することは不可能なので、ユーザーがファイルを透過的に処理できるようにするにはどうすればよいでしょうか?

たとえば、ファイルを書き込みたい場合、どのファイル システムを使用していても、具体的にどのように読み取るかに関係なく、直接読み取ることができます。ここで仮想ファイルシステムを導入する必要があります。

仮想ファイル システムは次のようになります。システムには、ext2、ext3、fat32、ntfs などの複数の「実際のファイル システム」が存在する可能性があります。たとえば、現在複数のパーティションがあり、各パーティションには異なる「実際のファイル システム」が存在する可能性があることがわかります。

たとえば、ext2、ext3、fat32 の 3 つのディスク パーティションがある場合、それぞれの「実際のファイル システム」の操作とデータ構造は異なる必要があります。では、ユーザーはどうすればそれらを透過的に使用できるのでしょうか?

このとき、中間層として VFS が必要になります。ユーザーは VFS と直接やり取りします。

VFS はメモリ内にのみ存在するソフトウェア メカニズムです。各システムの初期化中に、Linux はまずメモリ (つまり、ソース コード内の名前空間) 内に VFS ディレクトリ ツリーを構築します。

VFS の主な機能は、上位層アプリケーションを下位層のさまざまな呼び出し方法から保護し、統一された呼び出しインターフェイスを提供することです。 2 つ目は、さまざまなファイル システムの編成と管理を容易にすることです。

VFS は、POSIX API インターフェイスをさまざまなストレージ デバイスの特定のインターフェイス実装から分離する抽象化レイヤーを提供し、基盤となるファイル システム タイプとデバイス タイプを上位レベルのアプリケーションに対して透過的にします。

たとえば、読み取りと書き込みは、sys_read と sys_write として VFS にマップされます。その後、VFS は、操作している「実際のファイルシステム」(どのパーティション) に応じて、異なる実際の操作を実行できます。この技術もお馴染みの「フック構造」技術で対応しています。

実際、VFS は抽象的な struct 構造を提供し、特定のファイル システムごとに独自のフィールドと関数を入力することで、異種混合の問題を解決します (カーネルの多くのサブシステムがこのメカニズムを広範に使用しています)。

3. Linux仮想ファイルシステムの4つの主要オブジェクト

ファイルシステムを統一的に管理および整理するために、Linux はパブリック ルート ディレクトリとグローバル ファイルシステム ツリーを作成します。ファイル システム内のファイルにアクセスするには、まず、グローバル ファイル システム ツリーのルート ディレクトリの下にファイル システムをマウントする必要があります。このマウント プロセスはファイル システムのマウントと呼ばれ、マウントされたディレクトリはマウント ポイントと呼ばれます。

ディスク上の従来のファイル システムのレイアウトは次のとおりです。

上の図からわかるように、ファイル システムの先頭は通常、ディスク セクターで構成されるブート ブロックです。この部分の主な目的は、オペレーティング システムを起動することです。通常、オペレーティング システムの起動時にのみ使用されます。

次はスーパーブロックです。主に物理ディスク内のファイルシステム構造の関連情報を保存し、各部分のサイズを記述します。

最後に、i ノード ビットマップ、論理ブロック ビットマップ、i ノード、および論理ブロックが物理ディスク上に分散されます。

スーパーブロック、i-node、論理ブロックを効率的に管理するために、Linux はファイルシステムタイプ、inode、dentry など、いくつかの異なるデータ構造を作成します。

ファイル システム タイプは、特定のファイル システムの動作を指定します。データ構造を使用して、特定のファイル システム タイプのインスタンスを構築できます。また、インスタンスはスーパーブロックインスタンスとも呼ばれます。

スーパーブロックは、ファイルシステムの全体的な制御情報を反映します。スーパーブロックはさまざまな方法で存在できます。ディスクベースのファイルシステムの場合、特定の形式でディスクの固定領域（ファイルシステムの種類によって異なります）に存在します。ファイル システムがマウントされると、スーパーブロックの内容がディスクに読み込まれ、メモリ内に新しいスーパーブロックが構築されます。

inode は、ファイル システム オブジェクト内の一般的なメタデータ情報を反映します。 Dentry は、グローバル ファイル システム ツリー内のファイル システム オブジェクトの場所を反映します。

Linux はこれら 4 つのデータ構造間に関連する関連付けを行います。以下のように表示されます。

構造的関係

1. スーパーブロック

スーパー ブロック: スーパー ブロックはファイル システムに対応します (インストールされているファイル システムの種類は ext2 などです。ここでは VFS ではなく実際のファイル システムです)。

すでに述べたように、ファイル システムはこれらのファイルのデータ形式と操作を管理するために使用されます。システム ファイルには独自のファイル システムがあり、異なるディスク パーティションにも異なるファイル システムが存在する場合があります。スーパーブロックは独立したファイルシステム用です。ファイル システムの種類、サイズ、ステータスなどを保存します。

(「ファイルシステム」と「ファイルシステムタイプ」は異なります。ファイルシステムタイプには、多くのファイルシステム、つまり多くのスーパーブロックを含めることができます)

異なるファイル システムには異なる super_block があることがわかっているので、異なる super_block に対する操作は異なるはずであり、上記の抽象 struct 構造は次の super_block 構造で確認できます (たとえば、次の struct super_operations)。

 1246 構造体スーパーブロック {
 1247 構造体 list_head s_list; /* これを最初に保存します*/
 1248 dev_t s_dev; /* 検索インデックス; kdev_t ではない */
 1249 符号なしchar s_blocksize_bits;
 1250 符号なしlong s_blocksize;
 1251 loff_t s_maxbytes; /*最大ファイルサイズ*/
 1252 構造体ファイルシステムタイプ *s_type;
 1253 定数構造体 super_operations *s_op;
 1254 定数構造体dquot_operations *dq_op;
 1255 定数構造体 quotactl_ops *s_qcop;
 1256 定数構造体 export_operations *s_export_op;
 1257 符号なしlong s_flags;
 1258 符号なしロング s_magic;
 1259 構造体dentry *s_root;
 1260 構造体 rw_semaphore s_umount;
 1261整数s_count;
 1262 アトミックt s_active;
 1263 #ifdef CONFIG_SECURITY
 1264 void *s_security;
 1265 #終了
1266 定数構造体 xattr_handler **s_xattr;
 1267
 1268 構造体 list_head s_inodes; /*すべてのinode */
 1269 構造体 hlist_bl_head s_anon; /* (nfs) エクスポート用の匿名 dentry */
 1270 構造体list_head s_mounts; /* マウントのリスト; fsでは使用できません*/
 1271 構造体ブロックデバイス *s_bdev;
 1272 構造体 backing_dev_info *s_bdi;
 1273 構造体 mtd_info *s_mtd;
 1274 構造体 hlist_node s_instances;
 1275 構造体 quota_info s_dquot; /* ディスククォータ固有のオプション */
 1276
 1277 構造体 sb_writers s_writers;
 1278
 1279文字s_id[32]; /* 情報名*/
 1280 u8 s_uuid[16]; /* UUID */
 1281
 1282 void *s_fs_info; /* ファイルシステムのプライベート情報 */
 1283 符号なし整数s_max_links;
 1284 fmode_t s_mode;
 1285
 1286 /* c/m/atimeの粒度（ ns）。
 1287 2番目より悪くなることはない*/
 1288 u32 s_time_gran;
 1289
 1290 /*
 1291 *次のフィールドは  VFS *のみ* 。ファイルシステムは関係ない
1292 *見ても。警告されていました。
 1293 */
 1294 構造体ミューテックス s_vfs_rename_mutex; /* クラッジ */
 1295
 1296 /*
 1297 * ファイルシステムのサブタイプ。空でない場合はファイルシステムタイプフィールド
1298 * /proc/mountsでは"type.subtype"になります 
 1299 */
 1300文字*s_subtype;
 1301
 1302 /*
 1303 *遅延ファイルシステムのマウントオプションを保存しました。
 1304 * ジェネリック_show_options()
 1305 */
 1306文字__rcu *s_options;
 1307 定数構造体dentry_operations *s_d_op; /* dentriesのデフォルトのd_op */
 1308
 1309 /*
 1310 * cleancacheの保存プール識別子(-1 はなしを意味します)
 1311 */
 1312 int cleancache_poolid;
 1313
 1314 構造体シュリンク s_shrink; /* SBごとのシュリンクハンドル */
 1315
 1316 /* nlink == 0 だがまだ参照されているinodeの数*/
 1317 アトミックロングt s_remove_count;
 1318
 1319 /*読み取り専用で再マウント中*/
 1320 int s_readonly_remount;
 1321
 1322 /* AIO 完了は割り込みコンテキストから延期されます*/
 1323 構造体ワークキュー構造体 *s_dio_done_wq;
 1324
 1325 /*
 1326 * lruリストを最後に保存する 構造上、常に
1327 * 個別のキャッシュラインを所有します。
 1328 */
 1329 構造体 list_lru s_dentry_lru ____cacheline_aligned_in_smp;
 1330 構造体 list_lru s_inode_lru ____cacheline_aligned_in_smp;
 1331 構造体 rcu_head rcu;
 1332 };

説明フィールド:

スーパーブロック方式

  
構造体スーパーオペレーション{
        //この関数は、指定されたスーパーブロックの下に新しいインデックスノードオブジェクトを作成して初期化します
    構造体 inode *(*alloc_inode)(構造体 super_block *sb);
        //指定されたインデックスノードを解放します。
 void (*destroy_inode)(構造体inode *);
        //VFS はインデックス ノードが変更されたときにこの関数を呼び出します。
    void (*dirty_inode) (構造体inode *、 int flags);
        // 指定された inode をディスクに書き戻します。
 int (*write_inode) (構造体inode *、構造体writeback_control *wbc);
        //インデックスノードを削除します。
 int (*drop_inode) (構造体inode *); 
         
 void (*evict_inode) (構造体inode *);
        //スーパーブロックを解放するために使用される
 void (*put_super) (構造体 super_block *);
        // ファイル システムのデータ要素をディスク上のファイル システムと同期します。 wait パラメータは、操作が同期的かどうかを指定します。
 int (*sync_fs)(構造体 super_block *sb、 int wait);
 int (*freeze_fs) (構造体 super_block *);
 int (*unfreeze_fs) (構造体 super_block *);
        //ファイルシステムのステータスを取得します。ファイルシステム関連の統計情報をstatfsに格納する
int (*statfs) (構造体dentry *、構造体kstatfs *);
 int (*remount_fs) (構造体 super_block *, int *, char *);
 void (*umount_begin) (構造体 super_block *); 
  
 int (*show_options)(構造体 seq_file *、構造体 dentry *);
 int (*show_devname)(構造体 seq_file *、構造体 dentry *);
 int (*show_path)(構造体 seq_file *、構造体 dentry *);
 int (*show_stats)(構造体 seq_file *、構造体 dentry *);
 #ifdef CONFIG_QUOTA
 ssize_t (*quota_read)(構造体 super_block *, int , char *, size_t, loff_t);
 ssize_t (*quota_write)(構造体 super_block *, int , const char *, size_t, loff_t);
 #終了
int (*bdev_try_to_free_page)(構造体 super_block*、構造体 page*、gfp_t);
 long (*nr_cached_objects)(構造体 super_block *, int );
 long (*free_cached_objects)(struct super_block *, long, int );
 };

2. iノード

インデックス ノード inode: 実際のデータに関するいくつかの情報 (「メタデータ」と呼ばれる、ファイル属性の説明) が実際に保存されます。

たとえば、ファイル サイズ、デバイス ID、ユーザー ID、ユーザー グループ ID、ファイル モード、拡張属性、ファイルが読み取られたときまたは変更されたときのタイムスタンプ、リンクの数、コンテンツが保存されているディスク ブロックへのポインター、ファイル分類などです。

（データはメタデータ+データ自体に分かれていることに注意してください）

また、注意: inode には 2 つの種類があり、1 つは VFS の inode で、もう 1 つは特定のファイル システムの inode です。前者はメモリ内にあり、後者はディスク上にあります。したがって、毎回、ディスク上の inode が実際にメモリ内の inode に呼び出されてメモリが満たされるため、ディスク ファイルの inode は使用されていると見なされます。

inode はどのように生成されますか?

各 inode ノードのサイズは通常 128 バイトまたは 256 バイトです。 inode ノードの合計数はフォーマット時に指定され (最新の OS は動的に変更可能)、通常は 2KB ごとに 1 つの inode が設定されます。

一般的にファイルシステム内に2KB未満のファイルは少ないため、2KBごとに分割する予定です。通常、inode を使い切ることはできません。したがって、ファイルシステムがインストールされると、デフォルトの inode 数が設定され、後で実際のニーズに応じて変更されます。

inode 番号に注意してください。inode 番号は一意であり、異なるファイルを表します。実際、Linux では、ファイルは inode 番号を通じてアクセスされ、いわゆるファイル名はユーザーの便宜のためだけのものとなっています。

ファイルを開くと、まずシステムはファイル名に対応する inode 番号を見つけます。次に、inode 番号を通じて inode 情報を取得し、最後に inode を通じてファイル データが配置されているブロックを見つけます。これでファイルデータを処理できるようになりました。

inode とファイルの関係は何ですか?

ファイルが作成されると、そのファイルに inode が割り当てられます。 1 つの inode は 1 つの実際のファイルにのみ対応し、1 つのファイルには 1 つの inode のみが含まれます。最大 inode 数は最大ファイル数です。

 527 構造体iノード{
 528 umode_t i_mode; /* アクセス許可制御 */
 529 符号なしショート i_opflags;
 530 kuid_t i_uid; /* ユーザーID */
 531 kgid_t i_gid; /* グループIDを使用する */
 532 符号なし整数i_flags; /* ファイルシステムフラグ */
 533
 534 #ifdef CONFIG_FS_POSIX_ACL
 535 構造体 posix_acl *i_acl;
 536 構造体 posix_acl *i_default_acl;
 537 #終了
 538
 539 定数構造体inode_operations *i_op; /*インデックスノード操作テーブル*/
 540 構造体スーパーブロック *i_sb; /* 関連するスーパーブロック */
 541 構造体アドレス空間 *i_mapping; /* 関連アドレスマッピング */
 542
 543 #ifdef CONFIG_SECURITY
 544 void *i_security;
 545 #終了
 546
 547 /* 統計データ、パスウォーキングからはアクセスされません*/
 548 符号なしロング i_ino; /* インデックスノード番号 */
 549 /*
 550 * ファイルシステムは  i_nlink を直接読み取ります。彼らは
 551 * 変更のための次の関数:
 552 *
 553 * (設定| クリア | 増加 |削除)_nlink
 554 * inode_(inc| dec )_link_count
 555 */
 556組合{
 557 定数符号なしint i_nlink;
 558 符号なし整数__i_nlink; /* ハードリンクの数 */
 559 };
 560 dev_t i_rdev; /* 実際のデバイス識別子 */
 561 loff_t i_size;
 562 構造体timespec i_atime; /* 最終アクセス時間 */
 563 構造体timespec i_mtime; /* 最終更新時刻 */
 564 構造体timespec i_ctime; /* 最終変更時刻 */
 565 スピンロック_t i_lock; /* i_blocks、i_bytes、おそらくi_size */
 566 符号なしショート i_bytes; /* 使用されたバイト数 */
 567 符号なし整数i_blkbits;
 568ブロックi_blocks; /* ファイル内のブロック数 */
 569
 570 #ifdef __NEED_I_SIZE_ORDERED
 571 seqcount_t i_size_seqcount;
 572 #終了
573
 574 /* その他 */
 575 符号なしロングi_state;
 576 構造体ミューテックス i_mutex;
 577
 578 符号なしロング dirtied_when; /* jiffyの 最初のダーティ化の最初の変更時間*/
 579
 580 構造体 hlist_node i_hash; /* ハッシュ値、検索効率を向上 */
 581 構造体 list_head i_wb_list; /* バックアップデバイス IO リスト */
 582 構造体list_head i_lru; /* inode LRU 未使用 inode リスト*/
 583 構造体 list_head i_sb_list; /* ファイルシステム内のすべての inode のリストをリンクします */
 584組合{
 585 構造体 hlist_head i_dentry; /* ディレクトリネックレステーブル */
 586 構造体 rcu_head i_rcu;
 587 };
 588 u64 i_バージョン;
 589 アトミック i_count; /* 参照カウント */
 590 アトミックt i_dio_count;
 591 アトミック_t i_writecount; /* ライター数 */
 592 定数構造体ファイル操作 *i_fop; /* 以前の ->i_op->default_file_ops ファイル操作*/
 593 構造体ファイルロック *i_flock; /* ファイルロックリスト */
 594 構造体アドレス空間i_data; /* inode によって読み書きされるページを示します */
 595 #ifdef CONFIG_QUOTA
 596 struct dquot *i_dquot[MAXQUOTAS];/* ノードディスククォータ */
 597 #終了
 598 構造体list_head i_devices; /* デバイスリスト（同じドライバーを共有するデバイスのリスト）*/
 599組合{
 600 構造体 pipe_inode_info *i_pipe; /* パイプライン情報 */
 601 構造体ブロックデバイス *i_bdev; /* ブロックデバイスドライバーノード */
 602 構造体 cdev *i_cdev; /* 文字デバイス ドライバー ノード */
 603 };
 604
 605 __u32 i_生成; /* インデックスノードのバージョン番号 */
 606
 607 #ifdef CONFIG_FSNOTIFY
 608 __u32 i_fsnotify_mask; /* この inode が関係するすべてのイベント */
 609 構造体 hlist_head i_fsnotify_marks;
 610 #終了
 611
 612 #ifdef CONFIG_IMA
 613 アトミック_t i_readcount; /* 構造体ファイルは ROを開きます*/
 614 #終了
 615 void *i_private; /* fsまたはデバイス プライベート ポインター ユーザー プライベート データ*/
 616 };

inode を管理する 4 つのリンク リストに注意してください。

静的構造体 hlist_head *inode_hashtable __read_mostly;

ノードメソッド

構造体inode_operations{
 struct dentry * (*検索) (struct inode *、struct dentry *、unsigned int );
 void * (*follow_link) (構造体 dentry *、構造体 nameidata *);
 int (*permission) (構造体inode *, int );
 構造体 posix_acl * (*get_acl)(構造体 inode *, int ); 
  
 int (*readlink) (struct dentry *, char __user *, int );
 void (*put_link) (構造体dentry *、構造体nameidata *、void *); 
  
 int (*作成) (構造体 inode *、構造体 dentry *、umode_t、bool);
 int (*link) (struct dentry *、struct inode *、struct dentry *);
 int (*unlink) (構造体inode *、構造体dentry *);
 int (*symlink) (構造体 inode *、構造体 dentry *、const char *);
 int (*mkdir) (構造体inode *、構造体dentry *、umode_t);
 int (*rmdir) (構造体 inode *、構造体 dentry *);
 int (*mknod) (構造体 inode *、構造体 dentry *、umode_t、dev_t);
 int (*名前変更) (構造体inode *、構造体dentry *、
   構造体 inode *、構造体 dentry *);
 int (*rename2) (構造体inode *、構造体dentry *、
   構造体 inode *、構造体 dentry *、符号なしint );
 int (*setattr) (構造体dentry *、構造体iattr *);
 int (*getattr) (構造体 vfsmount *mnt、構造体 dentry *、構造体 kstat *);
 int (*setxattr) (構造体dentry *、const char *、const void *、size_t、 int );
 ssize_t (*getxattr) (構造体dentry *、const char *、void *、size_t);
 ssize_t (*listxattr) (構造体dentry *、 char *、size_t);
 int (*removexattr) (構造体dentry *、const char *);
 int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64 開始,
        u64 長さ);
 int (*update_time)(構造体inode *、構造体timespec *、 int );
 int (*atomic_open)(構造体inode *、構造体dentry *、
      構造体ファイル *、符号なし open_flag、
      umode_t create_mode、 int *開かれました);
 int (*tmpfile) (構造体 inode *、構造体 dentry *、umode_t);
 int (*set_acl)(構造体inode *、構造体posix_acl *、 int );
 } ____キャッシュラインを揃える;

重要な結果のいくつかが分析されています。

3) ディレクトリエントリ (dentry)

ディレクトリ エントリは、ファイルを記述する論理属性です。これらはメモリ内にのみ存在し、実際にはディスク上の記述に対応していません。より正確には、メモリ内に存在し、検索パフォーマンスを向上させるために設計されたディレクトリ エントリ キャッシュです。

フォルダーと最終ファイルは両方ともディレクトリ項目に属し、すべてのディレクトリ項目が一緒になって巨大なディレクトリ ツリーを形成することに注意してください。

たとえば、ファイル /home/xxx/yyy.txt を開くと、/、home、xxx、yyy.txt はすべてディレクトリ エントリになります。 VFS は検索時に、ディレクトリ エントリの層ごとに各ディレクトリ エントリに対応する inode を見つけ、次にディレクトリ エントリに沿って操作して最終的なファイルを見つけます。

注: ディレクトリもファイルです (したがって、対応する inode もあります)。ディレクトリを開くということは、実際にはディレクトリ ファイルを開くことを意味します。

 108 構造体dentry {
 109 /* RCU ルックアップがアクセスしたフィールド */
 110 符号なし整数d_flags; /* d_lockによって保護されています*/
 111 seqcount_t d_seq; /* dentry seqlock ごと */
 112 構造体 hlist_bl_node d_hash; /* ハッシュリストを検索 */
 113 構造体dentry *d_parent; /* 親ディレクトリ 親ディレクトリ */
 114 構造体qstr d_name;
 115 構造体inode *d_inode; / *名前が属する場所- NULL  は 
 116 * 負 このディレクトリエントリに関連付けられた inode */
 117 符号なしchar d_iname[DNAME_INLINE_LEN]; /* 小さな名前 短いファイル名 */
 118
 119 /* 参照検索は以下も参照します */
 120 構造体ロック参照 d_lockref; /* dentry ごとのロックと参照カウント */
 121 定数構造体dentry_operations *d_op; /* ディレクトリエントリ操作 */
 122 構造体スーパーブロック *d_sb; /* dentry ツリーのルートこのディレクトリ エントリが属するファイル システムのスーパー ブロック (ディレクトリ エントリ ツリーのルート)*/
 123 符号なしlong d_time; /* d_revalidate の再検証時間によって使用される*/
 124 void *d_fsdata; /* fs 固有のデータ 特定のファイルシステムデータ */
 125
 126 構造体list_head d_lru; /* LRU リストは、LRU アルゴリズムによってリンクされた未使用のディレクトリのリンク リストです */
 127 /*
 128 * d_childとd_rcuはメモリを共有できる
129 */
 130組合{
 131 構造体list_head d_child; /* 親リストのディレクトリエントリの子は、これを通じて親ディレクトリの d_subdirs に追加されます */
 132 構造体 rcu_head d_rcu;
 133 } d_u;
 134 構造体list_head d_subdirs; /* 私たちの子ディレクトリはすべてこのディレクトリのリストの先頭です */
 135 構造体 hlist_node d_alias; /* inode エイリアス リスト インデックス ノード エイリアス リスト*/
 136 };

ディレクトリ エントリはファイルまたはディレクトリのいずれかを表し、ディレクトリは実際にはファイルであるため、有効な dentry 構造には inode 構造が必要です。したがって、dentry 構造体が有効である限り、そのポインタ d_inode は inode 構造体を指している必要があります。しかし、inode は複数のものに対応することができます。

全体の構造は実際には木です。私のデバイス モデル kobject をご覧になったことがあるなら、ディレクトリは実際にはファイル (kobject、inode) とカプセル化のレイヤーであることがわかるでしょう。ここでのいわゆるカプセル化は、主に 2 つのポインタを追加します。1 つは親ディレクトリを指し、もう 1 つはディレクトリに含まれるすべてのファイル (通常のファイルとディレクトリ) のリンク リスト ヘッダーを指します。

これは、ディレクトリ操作を実行する方法です (たとえば、前のディレクトリに戻るには 1 つのポインタ ステップ [..] のみが必要ですが、サブディレクトリに入るにはリンク リストのインデックス作成が必要であり、複数のステップが必要です)

Dentry 関連の操作 (inode にはすでに mkdir、rmdir、mknod などの操作が含まれています)

構造体dentry_operations{
        /* この関数は、ディレクトリ オブジェクトが有効かどうかを判断します。 VFS は、dcache からディレクトリ エントリを使用する準備ができたときにこの関数を呼び出します。 */
 int (*d_revalidate)(構造体dentry *、符号なしint );
 int (*d_weak_revalidate)(構造体dentry *、符号なしint );
        /* このディレクトリのハッシュ値を生成します。ディレクトリ エントリをハッシュ テーブルに追加する場合は、VFS はこの関数を呼び出します。 */
 int (*d_hash)(const struct dentry *, struct qstr *);
        /* この関数は、2 つのファイル名 name1 と name2 を比較します。この機能を使用するには、dcache_lock ロックを追加する必要があります。 */
 int (*d_compare)(const struct dentry *, const struct dentry *,
   符号なしint 、const char *、const struct qstr *);
        /* d_count=0 の場合、VFS はこの関数を呼び出します。この関数を使用するには、dcache_lock を呼び出します。 */
 int (*d_delete)(const struct dentry *);
        /* VFS はディレクトリ オブジェクトを解放するときにこの関数を呼び出します。 */
 void (*d_release)(構造体dentry *);
 void (*d_prune)(構造体dentry *);
        /* VFS は、ディレクトリ エントリが inode を失ったときにこの関数を呼び出します。 */
 void (*d_iput)(構造体dentry *、構造体inode *);
 char *(*d_dname)(構造体dentry *, char *, int );
 構造体 vfsmount *(*d_automount)(構造体 path *);
 int (*d_manage)(構造体dentry *, bool);
 } ____キャッシュラインを揃える; 
  

4) ファイルオブジェクト（ファイル）

ファイル オブジェクトは、プロセスが開いたファイルを表します。ファイルは複数のプロセスによって開くことができるため、ファイルに対して複数のファイル オブジェクトが存在する場合があります。しかし、ファイルは一意であるため、inode は一意であり、ディレクトリ エントリも固定されています。

プロセスは実際にはファイル記述子を通じてファイルを操作します。各ファイルには、読み書きされる次のバイト位置を示す 32 ビットの番号があります。この番号はファイル位置と呼ばれます。

通常、ファイルを開いた後、特別な場合を除き、開く位置は 0 から始まります。 Linux はファイル構造を使用して開いているファイルの場所を保存するため、ファイルは開いているファイルの説明と呼ばれます。ファイル構造は、システム オープン ファイル テーブルと呼ばれる二重リンク リストを形成します。

ファイル

775 構造体ファイル {
 776組合{
 777 構造体 llist_node fu_llist; /* ファイルシステムで開かれた各ファイルは二重リンクリストを形成します */
 778 構造体 rcu_head fu_rcuhead;
 779 } ふ_u;
 780 構造体パス f_path;
 781 #define f_dentry f_path.dentry
 782 構造体inode *f_inode; /* キャッシュされた値 */
 783 定数構造体ファイル操作 *f_op; /* ファイル操作テーブルへのポインタ */
 784
 785 /*
 786 * f_ep_links、f_flagsを保護します。
 787 * IRQ コンテキストから取得してはなりません。
 788 */
 789 スピンロック f_lock;
 790 アトミックロングt f_count; /* ファイルオブジェクトの使用回数 */
 791 符号なし整数f_flags; /* ファイルを開くときに指定されるフラグ */
 792 fmode_t f_mode; /* ファイルアクセスモード（権限など） */
 793 構造体ミューテックス f_pos_lock;
 794 オフセット f_pos; /* ファイルの現在の変位 */
 795 構造体 fown_struct f_owner;
 796 定数構造体cred *f_cred;
 797 構造体 file_ra_state f_ra; /* 事前読み取りステータス */
 798
 799 u64 f_バージョン; /* バージョン番号 */
 800 #ifdef CONFIG_SECURITY
 801 void *f_security; /* セキュリティモジュール */
 802 #終了
 803 /* tty ドライバ、およびおそらく他のドライバに必要*/
 804 void *プライベートデータ; /* プライベートデータ */
 805
 806 #ifdef CONFIG_EPOLL
 807 /* fs/eventpoll.cによってこのファイルへのすべてのフックをリンクするために使用されます*/
 808 構造体 list_head f_ep_links;
 809 構造体 list_head f_tfile_llink;
 810 #endif /* #ifdef CONFIG_EPOLL */
 811 struct address_space *f_mapping;/* ページキャッシュマッピング */
 812 #ifdef CONFIG_DEBUG_WRITECOUNT
 813 符号なしlong f_mnt_write_state;
 814 #終了
 815 } __attribute__((aligned(4))); /* 少なくとも何か変なものが 2がOK だと判断する */

いくつかの重要なフィールドの説明に重点を置きます。

まず、f_flags、f_mode、f_pos は、現在ファイルを操作しているプロセスの制御情報を表します。これは非常に重要です。ファイルは複数のプロセスによって同時に開かれる可能性があり、各プロセスではファイルの操作は非同期であるため、これら 3 つのフィールドは非常に重要です。

参照カウント f_count の場合、プロセスのファイル記述子を閉じると、実際にはファイルは閉じられず、単に f_count が 1 減少するだけです。 f_count=0 の場合、実際に閉じます。 dup や fork などの操作の場合、 f_count が増加します。具体的な内容については後ほど説明します。

f_opも非常に重要です!すべてのファイルに関係する操作構造です。たとえば、ユーザーが read を使用すると、最終的には file_operations の read 操作が呼び出されますが、file_operations 構造は異なるファイル システムで同じではない可能性があります。重要な操作機能はリリース機能です。ユーザーが close を実行すると、実際にはカーネル内で release 関数が実行されます。この関数は f_count を 1 つだけ減らします。これは、ユーザーがファイルを閉じると、f_count が実際に 1 つ減少するという、上記で述べたことも説明しています。参照カウントが 0 になった場合にのみ、ファイルは閉じられます。

注: 二重リンク リストは、それぞれ「使用中」および「未使用」のファイル オブジェクトを管理するために使用されます。

ファイル構造体

上記のファイルは 1 つのファイルのみです。プロセス (ユーザー) では複数のファイルを同時に処理できるため、すべてのファイルを管理するには別の構造が必要です。

つまり、ユーザーがファイルテーブルを開く ---> files_struct

 172 構造体ファイル_構造体 {
 173 ATOMIC_Tカウント;
 174 rwlock_t file_lock; /*以下のすべてのメンバーを保護します。 tsk-> alloc_lock *内の巣
175 int max_fds;
 176 int max_fdset;
 177 int next_fd;
 178 struct file ** fd; / *現在のFDアレイ */
 179 fd_set *close_on_exec;
 180 fd_set *open_fds;
 181 fd_set close_on_exec_init;
 182 fd_set open_fds_init;
 183 struct file * fd_array [nr_open_default];
 184};

いくつかのフィールドを説明してください：

fs_struct

上記のファイルとfiles_structは、プロセス関連ファイルの情報を記録しますが、プロセス自体については、独自の情報の一部は何で表されますか？ここでは、FS_STRUCT構造を使用します。

 5 struct fs_struct {
 6 ATOMIC_Tカウント;
 7 rwlock_t lock;
 8 int umask;
 9 struct dentry * root、 * pwd、 * altroot;
 10 struct vfsmount * rootmnt、 * pwdmnt、 * altrootmnt;
 11};

いくつかのフィールドを説明してください：

注：実際に実行している場合、これらの3つのディレクトリは同じファイルシステムにない場合があります。たとえば、プロセスのルートディレクトリは通常、「 /」ノードにインストールされているextファイルシステムですが、現在の作業ディレクトリは /etcにインストールされているファイルシステムであり、ルートディレクトリの交換も別のファイルシステムに含まれている場合があります。 rootmnt、pwdmnt、altrootmnt：上記の3つのインストールポイントに対応します。

ファイルメソッド（操作）file_operations

 struct file_operations {
 structモジュール *所有者;
 loff_t（ *llseek）（struct file *、loff_t、 int ）;
 ssize_t（ * read ）（struct file *、 char __user *、size_t、loff_t *）;
 ssize_t（ *write）（struct file *、const char __user *、size_t、loff_t *）;
 ssize_t（ *aio_read）（struct kiocb *、const struct iovec *、unsigned long、loff_t）;
 ssize_t（ *aio_write）（struct kiocb *、const struct iovec *、unsigned long、loff_t）;
 ssize_t（ *read_iter）（struct kiocb *、struct iov_iter *）;
 ssize_t（ *write_iter）（struct kiocb *、struct iov_iter *）;
 int （ *iterate）（struct file *、struct dir_context *）;
 unsigned int （ *poll）（struct file *、struct poll_table_struct *）;
 long（ *locked_ioctl）（struct file *、unsigned int 、unsigned long）;
 long（ *compat_ioctl）（struct file *、unsigned int 、unsigned long）;
 int （ *mmap）（struct file *、struct vm_area_struct *）;
 int （ * open ）（struct inode *、struct file *）;
 int （ *flush）（struct file *、fl_owner_t id）;
 int （ *release）（struct inode *、struct file *）;
 int （ *fsync）（struct file *、loff_t、loff_t、 int datasync）;
 int （ *aio_fsync）（struct kiocb *、 int datasync）;
 int （ *fasync）（ int 、struct file *、 int ）;
 int （ *lock）（struct file *、 int 、struct file_lock *）;
 ssize_t（ *sendpage）（struct file *、struct page *、 int 、size_t、loff_t *、 int ）;
 unsigned long（ *get_unmapped_area）（struct file *、unsigned long、unsigned long、unsigned long、unsigned long）;
 int （*check_flags）（ int ）;
 int （ *flock）（struct file *、 int 、struct file_lock *）;
 ssize_t（ *splice_write）（struct pipe_inode_info *、struct file *、loff_t *、size_t、unsigned int ）;
 ssize_t（ *splice_read）（struct file *、loff_t *、struct pipe_inode_info *、size_t、unsigned int ）;
 int （ *setLease）（struct file *、long、struct file_lock **）;
 long（ *fallocate）（struct file *file、 int mode、loff_t offset、
     loff_t len）;
 int （ *show_fdinfo）（struct seq_file *m、struct file *f）;
 };

上記は、米国のドライバー開発者にとって最も馴染みのあるものでなければならず、習得する必要があります。

4.プロセスとこれら4つの関係

プロセスを管理するためにカーネルで使用される構造は、task_structです。ファイルを開くプロセスには、上記の4つの重要なデータ構造が含まれます。

ファイル
fs_struct
 files_struct
名前空間

各プロセスには独自の名前空間があります。

FS_STRUCTは、現在の作業ディレクトリ、プロセスのルートディレクトリなど、プロセスとファイルシステムの構造的関係を表すために使用されます。

files_structは、現在のプロセスによって開かれたファイルを表すために使用されます。

開いたファイルごとに、ファイルオブジェクトで表されます。

Linuxでは、ファイル記述子がオープンファイルを表すためにしばしば使用され、この記述子の値は多くの場合、0以上の整数です。この整数は、実際にはファイルfils_structのファイル配列fdの添え字です。すべてのオープンファイルについて、これらのファイル記述子はopen_fdsビットマップに保存されます。

プロセスとスーパーブロック、ファイル、インデックスノード、ディレクトリ項目の関係

図から次のことがわかります。

• このプロセスは、domain files-> task_structのfiles_structを使用して、現在開いているファイルオブジェクトを理解します。そして、通常呼び出すファイル記述子は、実際にはプロセスによって開かれたファイルオブジェクト配列のインデックス値です。
• ファイルオブジェクトは、ドメインf_dentryを介して対応するデントリーオブジェクトを見つけ、次にデントリーオブジェクトのドメインd_inodeが対応するイノードを見つけます（スーパーブロックの情報はイノードを介して取得できるため、ファイルを操作する最終的な方法を取得できます。これはファイルを開くときにプロセスです。
• ファイルオブジェクトに対応するファイル操作関数のリストは、INODEのドメインI_FOPを介して取得され、I_FOPは最終的にstruct super_operations *s_opを介して初期化されます。

VFSファイルシステム内のイノードとデントリーは、実際のファイルシステムのINODEおよびDENTRYと特定の関係を持っていますが、同等ではありません。

実際のディスクファイルのイノードとデントリは物理的な外部メモリに存在しますが、VFSのイノードとデントリはメモリに存在します。システムが特定の処理のために外部メモリでイノードとデントリの情報を読み取った後、メモリ内のイノードとデントリを生成します。

仮想ファイルシステムには、InodeおよびDentry構造もありますが、これは対応するルールに従ってシステムによって生成され、実際の外部メモリには存在しません。

V.ディスクおよびファイルシステム

ディスクがいくつかのパーティションに分割されているとし、各パーティションが異なるファイルシステムであるとします。

ディスクとファイルシステム

参照記事：csdn-xiaodao dao侵害と削除

https://blog.csdn.net/qq_16777851/article/details/82914514

http://www.360doc.com/content/12/0503/19/9555338_208437965.shtml

https://www.sohu.com/a/326449573_467784

この記事は、WeChat Publicアカウント「Yikou Linux」から転載されています。下のQRコードからフォローできます。この記事を転載するには、Yikou Linuxの公式アカウントにお問い合わせください。