ext2/3/4的inode结构说明

系统环境:Ubuntu15.10/ext4

今天在复习《鸟哥的私房菜-基础学习篇》,看到inode大小为128bytes,想看下这128字节里面到底是什么样的。

于是我查了下google,发现ext2/3是128字节,ext4是256字节,以下是ext2/ext4对应的结构。

ext2.h/ext2_inode:

294 /*
295  * Structure of an inode on the disk
296  */
297 struct ext2_inode {
298         __le16  i_mode;         /* File mode */
299         __le16  i_uid;          /* Low 16 bits of Owner Uid */
300         __le32  i_size;         /* Size in bytes */
301         __le32  i_atime;        /* Access time */
302         __le32  i_ctime;        /* Creation time */
303         __le32  i_mtime;        /* Modification time */
304         __le32  i_dtime;        /* Deletion Time */
305         __le16  i_gid;          /* Low 16 bits of Group Id */
306         __le16  i_links_count;  /* Links count */
307         __le32  i_blocks;       /* Blocks count */
308         __le32  i_flags;        /* File flags */
309         union {
310                 struct {
311                         __le32  l_i_reserved1;
312                 } linux1;
313                 struct {
314                         __le32  h_i_translator;
315                 } hurd1;
316                 struct {
317                         __le32  m_i_reserved1;
318                 } masix1;
319         } osd1;                         /* OS dependent 1 */
320         __le32  i_block[EXT2_N_BLOCKS];/* Pointers to blocks */
321         __le32  i_generation;   /* File version (for NFS) */
322         __le32  i_file_acl;     /* File ACL */
323         __le32  i_dir_acl;      /* Directory ACL */
324         __le32  i_faddr;        /* Fragment address */
325         union {
326                 struct {
327                         __u8    l_i_frag;       /* Fragment number */
328                         __u8    l_i_fsize;      /* Fragment size */
329                         __u16   i_pad1;
330                         __le16  l_i_uid_high;   /* these 2 fields    */
331                         __le16  l_i_gid_high;   /* were reserved2[0] */
332                         __u32   l_i_reserved2;
333                 } linux2;
334                 struct {
335                         __u8    h_i_frag;       /* Fragment number */
336                         __u8    h_i_fsize;      /* Fragment size */
337                         __le16  h_i_mode_high;
338                         __le16  h_i_uid_high;
339                         __le16  h_i_gid_high;
340                         __le32  h_i_author;
341                 } hurd2;
342                 struct {
343                         __u8    m_i_frag;       /* Fragment number */
344                         __u8    m_i_fsize;      /* Fragment size */
345                         __u16   m_pad1;
346                         __u32   m_i_reserved2[2];
347                 } masix2;
348         } osd2;                         /* OS dependent 2 */
349 };

ext4.h/ext4_inode:

688 /*
689  * Structure of an inode on the disk
690  */
691 struct ext4_inode {
692         __le16  i_mode;         /* File mode */
693         __le16  i_uid;          /* Low 16 bits of Owner Uid */
694         __le32  i_size_lo;      /* Size in bytes */
695         __le32  i_atime;        /* Access time */
696         __le32  i_ctime;        /* Inode Change time */
697         __le32  i_mtime;        /* Modification time */
698         __le32  i_dtime;        /* Deletion Time */
699         __le16  i_gid;          /* Low 16 bits of Group Id */
700         __le16  i_links_count;  /* Links count */
701         __le32  i_blocks_lo;    /* Blocks count */
702         __le32  i_flags;        /* File flags */
703         union {
704                 struct {
705                         __le32  l_i_version;
706                 } linux1;
707                 struct {
708                         __u32  h_i_translator;
709                 } hurd1;
710                 struct {
711                         __u32  m_i_reserved1;
712                 } masix1;
713         } osd1;                         /* OS dependent 1 */
714         __le32  i_block[EXT4_N_BLOCKS];/* Pointers to blocks */
715         __le32  i_generation;   /* File version (for NFS) */
716         __le32  i_file_acl_lo;  /* File ACL */
717         __le32  i_size_high;
718         __le32  i_obso_faddr;   /* Obsoleted fragment address */
719         union {
720                 struct {
721                         __le16  l_i_blocks_high; /* were l_i_reserved1 */
722                         __le16  l_i_file_acl_high;
723                         __le16  l_i_uid_high;   /* these 2 fields */
724                         __le16  l_i_gid_high;   /* were reserved2[0] */
725                         __le16  l_i_checksum_lo;/* crc32c(uuid+inum+inode) LE */
726                         __le16  l_i_reserved;
727                 } linux2;
728                 struct {
729                         __le16  h_i_reserved1;  /* Obsoleted fragment number/size which are removed in ext4 */
730                         __u16   h_i_mode_high;
731                         __u16   h_i_uid_high;
732                         __u16   h_i_gid_high;
733                         __u32   h_i_author;
734                 } hurd2;
735                 struct {
736                         __le16  h_i_reserved1;  /* Obsoleted fragment number/size which are removed in ext4 */
737                         __le16  m_i_file_acl_high;
738                         __u32   m_i_reserved2[2];
739                 } masix2;
740         } osd2;                         /* OS dependent 2 */
741         __le16  i_extra_isize;
742         __le16  i_checksum_hi;  /* crc32c(uuid+inum+inode) BE */
743         __le32  i_ctime_extra;  /* extra Change time      (nsec << 2 | epoch) */
744         __le32  i_mtime_extra;  /* extra Modification time(nsec << 2 | epoch) */
745         __le32  i_atime_extra;  /* extra Access time      (nsec << 2 | epoch) */
746         __le32  i_crtime;       /* File Creation time */
747         __le32  i_crtime_extra; /* extra FileCreationtime (nsec << 2 | epoch) */
748         __le32  i_version_hi;   /* high 32 bits for 64-bit version */
749         __le32  i_projid;       /* Project ID */
750 };

可以看见ext4_inode仅仅是最下面多了一点内容。

Inode Size

In ext2 and ext3, the inode structure size was fixed at 128 bytes (EXT2_GOOD_OLD_INODE_SIZE) and each inode had a disk record size of 128 bytes. Starting with ext4, it is possible to allocate a larger on-disk inode at format time for all inodes in the filesystem to provide space beyond the end of the original ext2 inode. The on-disk inode record size is recorded in the superblock as s_inode_size. The number of bytes actually used by struct ext4_inode beyond the original 128-byte ext2 inode is recorded in the i_extra_isize field for each inode, which allows struct ext4_inode to grow for a new kernel without having to upgrade all of the on-disk inodes. Access to fields beyond EXT2_GOOD_OLD_INODE_SIZE should be verified to be within i_extra_isize. By default, ext4 inode records are 256 bytes, and (as of October 2013) the inode structure is 156 bytes (i_extra_isize = 28). The extra space between the end of the inode structure and the end of the inode record can be used to store extended attributes. Each inode record can be as large as the filesystem block size, though this is not terribly efficient.

官方说i_extra_isize是28字节,2013年8月,ext4_inode是156字节(128+28),但我今天贴的ext4_inode代码,后面的i_extra_isize部分应该

是32字节(i_extra_isize + i_checksum_hi + 28),所以ext4_inode应该是160字节(128+32)。

linux的ext4文件系统的inode是256字节,ext4_inode却只有160字节,那160到255字节有啥用呢,它们可以用来存放其它属性,如ACL,SELinux的属性。

I think by default current versions of mkfs.ext2/3/4 default to 256 byte inode size (see /etc/mke2fs.conf). This IIRC enables nanosecond timestamps with ext4, and as you say, more extended attributes fit within the inode. Such extended attributes are, for instance, ACL‘s, SELinux labels, some Samba specific labels.

Bigger inodes of course waste a little bit of space, and as you make them bigger you get into diminishing returns territory pretty quickly. The default 256 bytes is probably a perfectly good compromise for most situations.

参考

ext2.h:http://lxr.free-electrons.com/source/fs/ext2/ext2.h#L297

ext4.h:http://lxr.free-electrons.com/source/fs/ext4/ext4.h#L688

ext4的inode介绍:https://ext4.wiki.kernel.org/index.php/Ext4_Disk_Layout#Inode_Size

ext4扩展部分使用介绍:http://serverfault.com/questions/143691/linux-why-change-inode-size

时间: 2024-10-12 18:46:10

ext2/3/4的inode结构说明的相关文章

inode结构体及软链接和硬链接

首先先了解一下block(块的概念),块是文件存取的最小单位,通常8个扇区为一个块,而每个扇区的大小为512个字节也就是0.5K,所以一个块的大小也就是8*0.5K=4K. 系统通过inode来识别文件 可以用命令stat查看某文件的inode信息,如:stat client.c 可看到除了文件名以外的文件信息都在inode中 因此,inode是保存文件的信息的,称为索引节点 命令: stat 文件名     //查看某个文件的inode信息 df -i         //查看硬盘分区的ino

inode结构体

inode分为内存中的inode和文件系统中的inode,为了避免混淆,我们称前者为VFS inode, 而后者以EXT2为代表,我们称为Ext2 inod.这里说明的是VFS inode. 重要成员: 1. struct cdev *i_cdev; 若是字符设备,为其对应的cdev结构体指针. 2. struct block_device *i_bdev; 若是块设备,为其对应的block_device结构体指针 3. dev_t i_rdev; 若是设备文件,此成员记录设备的设备号 1 st

3. file、inode结构体及chardevs数组等相关知识解析

https://blog.csdn.net/zqixiao_09/article/details/50850004 下图描述了Linux中虚拟文件系统,一般的设备文件与设备驱动程序间的函数调用关系 上图展现了一个应用程序调用字符设备驱动的过程,在设备驱动程序的设计中,一般而言,会关系file和inode这两个结构体. 用户空间使用open()函数打开一个字符设备fd = open("/dev/hello", o_READ);这一函数会调用两个数据结构struct inode{}&

Linux文件系统详解(文件系统层次、分类、存储结构、存储介质、文件节点inode)

从操作系统的角度详解Linux文件系统层次.文件系统分类.文件系统的存储结构.不同存储介质的区别(RAM.ROM.Flash).存储节点inode. 本文参考:http://blog.chinaunix.net/uid-8698570-id-1763151.html http://www.iteye.com/topic/816268 http://soft.chinabyte.com/os/142/12315142.shtml http://www.ibm.com/developerworks/

文件存储结构inode与RAM结构建立联系

linux下一切皆文件,大致可分为以下几类:目录.普通文件.硬连接.软连接.字符设备.块设备.FIFO.Socket,其在物理存储体内存储按inode和数据块存储,inode代表元数据,是除实际数据外的所有(属性)数据.根据不同的文件类型有以下几种情况: >对于常规文件,文件的数据存储在数据块中,其他数据(即属性)存储在inode中. >对于目录,该目录下的所有文件名和目录名存储在数据块中,注意文件名保存在它所在目录的数据块中,除文件名之外,ls -l命令看到的其它信息都保存在该文件的inod

inode file 结构

inode位图(inode Bitmap) 和块位图类似,本身占一个块,其中每个bit表示一个inode是否空闲可用. inode表(inode Table) 我们知道,一个文件除了数据需要存储之外,一些描述信息也需要存储,例如文件类型(常规.目录.符号链接等),权限,文件大小,创建/修改/访问时间等,也就是ls -l命令看到的那些信息,这些信息存在inode中而不是数据块中.每个文件都有一个inode,一个块组中的所有inode组成了inode表. inode表占多少个块在格式化时就要决定并写

ext2元数据结构

概述 本篇博客主要描述ext2文件系统中的各种典型元数据结构,其中包括文件系统级别的元数据,如超级块,块组描述符等,也包括文件级的元数据,如文件目录项,文件inode等. ext2超级块 这里的超级块指的是ext2文件系统存储在磁盘上的超级块结构,之所以这么说是因为每个文件系统除了存储在磁盘上的超级块外,还在内存中也存储了一个超级块结构,基本上内存中的超级块是在磁盘超级块的基础上增加了一些额外的管理信息而成,因此,在这里我们主要关注的是ext2存储在磁盘上的超级块的数据结构. ext2磁盘超级块

Linux字符设备中的两个重要结构体(file、inode)

对于Linux系统中,一般字符设备和驱动之间的函数调用关系如下图所示 上图描述了用户空间应用程序通过系统调用来调用程序的过程.一般而言在驱动程序的设计中,会关系 struct file 和 struct inode 这两个结构体. 用户空间使用open()系统调用函数打开一个字符设备时( int fd = open("dev/demo", O_RDWR) )大致有以下过程: 在虚拟文件系统VFS中的查找对应与字符设备对应 struct inode节点 遍历字符设备列表(chardevs

ext2 的inode 为什么在格式化磁盘时候,就确定有多少个

ext2.不是使用inode来作为文件信息的管理么,那么为什么说 inode和 block在磁盘格式化的时候,就知道有多少个 block 还好说,block 是用来存储实际的文件内容的,根据磁盘就可以得到可以分配出多少个block,但是inode是记录文件 的属性内容,难道inode 的数量,是在初始化的时候,就固定了,还是也是基于磁盘得到一个inode的大致数量, 百思不得其姐 原文地址:https://www.cnblogs.com/wangchaodong/p/11965602.html