我们使用mysql常使用innodb存储引擎，它包括两种，一种是innobase,另外一种是innodb plugin。今天主要介绍innodb plugin的file I/O操作，innodb plugin存储引擎的文件操作主要包括下面三个重要的结构体:

　　fil_node_struce 一个node对应着一个文件

　　fil_space_struct 一个space对应着一个tablespace

　　fil_system_struct innodb tablespace memory cache

　　下面分别简单介绍三个结构体,这三个结构体的一些成员变量可以标示这三个结构体所构成的关系，它们是如何关联在一起的。

　　第一个重要的结构体，node是数据文件在内存中对应的一个管理结构

　　/** File node of a tablespace or the log data space */

　　struct fil_node_struct {

　　//指向这个node所在的tablespace

　　fil_space_t* space;

　　//这个文件的名字，包含了路径

　　char* name; /*!< path to the file */

　　//这个node是否处于打开状态，这个依附于下面的成员变量hanlde的值

　　ibool open; /*!< TRUE if file open */

　　//文件打开的句柄

　　os_file_t handle; /*!< OS handle to the file, if file open */

　　//这个node所对应的文件，是否使用raw disk

　　ibool is_raw_disk;

　　//文件大小，多少个页

　　ulint size; /*!< size of the file in database pages, 0 if

　　not known yet; the possible last incomplete

　　megabyte may be ignored if space == 0 */

　　//多少个pending i/o,mysql有自己的异步I/O机制,接下来三个参数也都与此有关

　　ulint n_pending;

　　/*!< count of pending i/o’s on this file;

　　closing of the file is not allowed if

　　this is > 0 */

　　ulint n_pending_flushes;

　　/*!< count of pending flushes on this file;

　　closing of the file is not allowed if

　　this is > 0 */

　　ib_int64_t modification_counter;/*!< when we write to the file we

　　increment this by one */

　　ib_int64_t flush_counter;/*!< up to what

　　modification_counter value we have

　　flushed the modifications to disk */

　　//这是一个结构体，表示双向链表中的一个field，通过它可以知道前一个node,后一个node,这些node都属于同一个表空间

　　UT_LIST_NODE_T(fil_node_t) chain;

　　/*!< link field for the file chain */

　　//这是一个结构体，表示LRU双向链表中的一个field,通过它可以知道前一个node,后一个node，这些node可能属于不同的表空间,这个LRU的base node存在fil_system_struct中。

　　UT_LIST_NODE_T(fil_node_t) LRU;

　　/*!< link field for the LRU list */

　　ulint magic_n;/*!< FIL_NODE_MAGIC_N */

　　};

　　第二个重要的结构体，表空间space，从逻辑上讲，一个表空间space包含一个node,或者多个node

　　/** Tablespace or log data space: let us call them by a common name space */

　　struct fil_space_struct {

　　char* name; /*!< space name = the path to the first file in it */

　　//每个表空间都有唯一的一个ID

　　ulint id; /*!< space id */

　　//表空间的version

　　ib_int64_t tablespace_version;

　　ibool mark; /*!< this is set to TRUE at database startup if

　　the space corresponds to a table in the InnoDB

　　data dictionary; so we can print a warning of

　　orphaned tablespaces */

　　//这个表空间停止新的i/o操作，比如文件改名操作

　　ibool stop_ios;

　　ibool stop_ibuf_merges;

　　/*!< we set this TRUE when we start

　　deleting a single-table tablespace */

　　//是否正在被删除

　　ibool is_being_deleted;

　　/*!< this is set to TRUE when we start

　　deleting a single-table tablespace and its

　　file; when this flag is set no further i/o

　　or flush requests can be placed on this space,

　　though there may be such requests still being

　　processed on this space */

　　//这个表空间的用途，主要有三种FIL_TABLESPACE, FIL_LOG, or FIL_ARCH_LOG

　　ulint purpose;

　　//双向链表的基结点，管理这个表空间所有的nodes

　　UT_LIST_BASE_NODE_T(fil_node_t) chain;

　　/*!< base node for the file chain */

　　//这个表空间的大小

　　ulint size; /*!< space size in pages; 0 if a single-table

　　tablespace whose size we do not know yet;

　　last incomplete megabytes in data files may be

　　ignored if space == 0 */

　　ulint flags; /*!< compressed page size and file format, or 0 */

　　ulint n_reserved_extents;

　　/*!< number of reserved free extents for

　　ongoing operations like B-tree page split */

　　//这个表空间的pending flushes个数,如果这个值>0,这个表空间不允许删除。

　　ulint n_pending_flushes;

　　//mysql特有的insert buffer,你还记得它的作用是什么吗?它存在什么地方?

　　ulint n_pending_ibuf_merges;/*!< this is positive

　　when merging insert buffer entries to

　　a page so that we may need to access

　　the ibuf bitmap page in the

　　tablespade: dropping of the tablespace

　　is forbidden if this is positive */

　　//两个hash表，提供两种快速访问node，或者table的方法

　　hash_node_t hash; /*!< hash chain node */

　　hash_node_t name_hash;/*!< hash chain the name_hash table */

　　#ifndef UNIV_HOTBACKUP

　　//定义的一个latch，来控制这个space结构体的并发操作

　　rw_lock_t latch; /*!< latch protecting the file space storage

　　allocation */

　　#endif /* !UNIV_HOTBACKUP */

　　//双向链表的一个field,通过这个成员变量，可以找到前一个unflushed space,以及下一个unflushed space，双向链表的基结点存在于fil_system_struce的unflushed_spaces里

　　UT_LIST_NODE_T(fil_space_t) unflushed_spaces;

　　ibool is_in_unflushed_spaces; /*!< TRUE if this space is

　　currently in unflushed_spaces */

　　//双向链表的一个field,这个双向链表保存整个系统所有的tablespace,这个双向链表的基结点存在于fil_system_struct的space_list中

　　UT_LIST_NODE_T(fil_space_t) space_list;

　　/*!< list of all spaces */

　　ulint magic_n;/*!< FIL_SPACE_MAGIC_N */

　　};

　　/** Value of fil_space_struct::magic_n */

　　#define FIL_SPACE_MAGIC_N 89472

　　第三个重要的结构体tablespace memory cache，它是一个入口，通过它可以找到所有的spaces,node的LRU链表，待刷新的unflushed spaces

　　/** The tablespace memory cache */

　　typedef struct fil_system_struct fil_system_t;

　　/** The tablespace memory cache; also the totality of logs (the log

　　data space) is stored here; below we talk about tablespaces, but also

　　the ib_logfiles form a ‘space’ and it is handled here */

　　struct fil_system_struct {

　　#ifndef UNIV_HOTBACKUP

　　//定义一个mutex,用来保护对此结构的并发访问

　　mutex_t mutex; /*!< The mutex protecting the cache */

　　#endif /* !UNIV_HOTBACKUP */

　　//hash表，根据space_id能快速定位space

　　hash_table_t* spaces;

　　//hash表，根据space_name能快速定位到space

　　hash_table_t* name_hash;

　　//所有打开的，并且没有pending i/o的文件node，都会放入到LRU链表中进行淘汰，系统表空间，以及日志的文件不会放入到此LRU链表当中

　　UT_LIST_BASE_NODE_T(fil_node_t) LRU;

　　/*!< base node for the LRU list of the

　　most recently used open files with no

　　pending i/o’s; if we start an i/o on

　　the file, we first remove it from this

　　list, and return it to the start of

　　the list when the i/o ends;

　　log files and the system tablespace are

　　not put to this list: they are opened

　　after the startup, and kept open until

　　shutdown */

　　//所有发生了数据改写的space，都会入到unflushed_spaces,如果想知道哪些spaces需要刷i/o,只需要遍历此链表即可

　　UT_LIST_BASE_NODE_T(fil_space_t) unflushed_spaces;

　　/*!< base node for the list of those

　　tablespaces whose files contain

　　unflushed writes; those spaces have

　　at least one file node where

　　modification_counter > flush_counter */

　　//当前打开文件的个数

　　ulint n_open; /*!< number of files currently open */

　　//系统允许打开的文件个数,这是一个软限制，不是一个硬限制，如果是单表空间，这个成员变量所对应的innodb_open_files参数需要设大

　　ulint max_n_open; /*!< n_open is not allowed to exceed

　　this */

　　ib_int64_t modification_counter;/*!< when we write to a file we

　　increment this by one */

　　ulint max_assigned_id;/*!< maximum space id in the existing

　　tables, or assigned during the time

　　mysqld has been up; at an InnoDB

　　startup we scan the data dictionary

　　and set here the maximum of the

　　space id’s of the tables there */

　　ib_int64_t tablespace_version;

　　/*!< a counter which is incremented for

　　every space object memory creation;

　　every space mem object gets a

　　’timestamp’ from this; in DISCARD/

　　IMPORT this is used to check if we

　　should ignore an insert buffer merge

　　request */

　　//双向链表的基结点，管理着全部的spaces

　　UT_LIST_BASE_NODE_T(fil_space_t) space_list;

　　/*!< list of all file spaces */

　　};

　　/** The tablespace memory cache. This variable is NULL before the module is

　　initialized. */

　　static fil_system_t* fil_system = NULL;

　　这几个结构体里的UT_LIST_BASE_NODE_T(),UT_LIST_NODE_T()，可以看一下宏定义，以增强大家对以上三个结构体三者之间关系的理解。

#define UT_LIST_BASE_NODE_T(TYPE) 　　struct { 　　ulint count; /*!< count of nodes in list */ 　　TYPE * start; /*!< pointer to list start, NULL if empty */ 　　TYPE * end; /*!< pointer to list end, NULL if empty */ 　　} 　　#define UT_LIST_NODE_T(TYPE) 　　struct { 　　TYPE * prev; /*!< pointer to the previous node, 　　NULL if start of list */ 　　TYPE * next; /*!< pointer to next node, NULL if end of list */ 　　}

　　在Fil0fil.c文件里定义上如上的三个重要的结构体，里面还有很多函数，都是围绕着这三个结构体展开，这些函数完成innodb 的文件i/o操作。平时应多读读代码，在代码结构里，更容易去理解mysql innodb plugin的运行原理，对代码的理解，如果碰到一些bug,也可以知道怎么样绕开这个bug，这是一件挺有意思的事。