Linux Kernel: VFS

1.2.1.3.1. fsync 导致的 write_inode

sys_fsync(int fd):
  if (!file->f_op || !file->f_op->fsync):
    /* Why?  We can still call filemap_fdatawrite */
    return
  mapping = file->f_mapping;
  filemap_fdatawrite(mapping);
  file->f_op->fsync(file, file->f_dentry, 0);
    ext2_sync_file
      sync_mapping_buffers
      ext2_sync_inode
        sync_inode
          __writeback_single_inode
            __sync_single_inode
              do_writepages
              write_inode
                inode->i_sb->s_op->write_inode(inode, sync);

1.2.1.3.2. dirty page balance 导致的 write_inode (vm_dirty_ratio)

generic_file_buffered_write:
  balance_dirty_pages
    writeback_inodes
      sync_sb_inodes
        __writeback_single_inode

1.2.2.3.1. getattr

vfs_stat:
  user_path_walk(name, &nd);
  vfs_getattr(nd.mnt, nd.dentry, stat);
    if (inode->i_op->getattr):
      return inode->i_op->getattr(mnt, dentry, stat);
    generic_fillattr(inode, stat);
      stat->dev = inode->i_sb->s_dev;
      stat->ino = inode->i_ino;
      stat->mode = inode->i_mode;
      stat->nlink = inode->i_nlink;
      stat->uid = inode->i_uid;
      stat->gid = inode->i_gid;
      stat->rdev = inode->i_rdev;
      stat->atime = inode->i_atime;
      stat->mtime = inode->i_mtime;
      stat->ctime = inode->i_ctime;
      stat->size = i_size_read(inode);
      stat->blocks = inode->i_blocks;
      stat->blksize = inode->i_blksize;

1. 关于文件大小
   

   stat 返回的信息中, 有两个和文件大小相关的值: stat->size 和 stat->blocks

   其中 stat->size 被称为 apparent size, stat->blocks 称为 disk usage

   $> truncate --size +10M a
   
   $> stat a
     File: 'a'
     Size: 31457280        Blocks: 0          IO Block: 4096   regular file
   Device: 802h/2050d      Inode: 21500388    Links: 1
   
   $> du -k a
   0       a
   
   $> du --apparent-size -k a
   30720   a
   
   

1.2.2.3.2. setattr

1. UID
   

   sys_chmod:
     notify_change(nd.dentry, &newattrs);
       if (inode->i_op && inode->i_op->setattr):
         inode->i_op->setattr(dentry, attr);
       else:
         inode_setattr(inode, attr);
           if (ia_valid & ATTR_UID):
             inode->i_uid = attr->ia_uid;
           else if xxx:
             // ...
           mark_inode_dirty(inode);
   

2. ATIME / MTIME
   

   读写文件时 atime/mtime 会相应变化, vfs 在 generic_file_read / write 处做了实现, 如果某个 fs 的文件读写不是通过 generic_file_read / write, 需要自己处理 ATIME/MTIME

1.3.2.2.1. populate_rootfs

populate_rootfs:
  // __initramfs_start 是 initramfs 镜像提前被加载到的内存位置
  // unpack_to_rootfs 需要做两件事:
  // 1. 对 __initramfs_start 位置的内容进行 gunzip
  // 2. 将对应的 cpio 内容加载到 rootfs 中, 所谓的 "加载", 实际就是通过 sys_open, sys_mkdir 等
  // 在 / 下临时生成文件和目录, 并通过 sys_chmod 等修改 owner 和权限
  // 参考: http://ieroot.com/2014/04/21/1534.html or  http://tinyurl.com/gslj9hf
  unpack_to_rootfs(__initramfs_start, __initramfs_end - __initramfs_start, 0);
    // 解析 initramfs 内容, 最后调用 do_name 在初始的 rootfs 中生成相应的文件
    write_buffer
      do_start
      do_header
      do_name
        // cpio 的末尾是 TRAILER!!!
        if (strcmp(collected, "TRAILER!!!") == 0):
          return;
        if (S_ISREG(mode)):
          sys_open(collected, O_WRONLY|O_CREAT, mode);
          sys_fchown(wfd, uid, gid);
          sys_fchmod(wfd, mode);
          do_copy
        else if (S_ISDIR(mode)):
          // xxx

1.3.2.2.2. prepare_namespace

prepare_namespace:
  sys_mount("devfs", "/dev", "devfs", 0, NULL);
  // root_device_name 是 boot 时指定的 kernel 参数
  ROOT_DEV = name_to_dev_t(root_device_name);
  if (initrd_load()):
    goto out;  
  mount_root()
    create_dev("/dev/root", ROOT_DEV, root_device_name);
    mount_block_root("/dev/root", root_mountflags);
      char *fs_names = __getname();
      get_fs_names(fs_names);
      // 尝试所有支持的 fstype
      for (p = fs_names; *p; p += strlen(p)+1):
        err = do_mount_root(name, p, flags, root_mount_data);
        if error == 0:
          break;
  out:
  sys_mount(".", "/", NULL, MS_MOVE, NULL);
  sys_chroot(".");
    set_fs_root(current->fs, nd.mnt, nd.dentry);

do_mount_root:
  // 把 /dev/root mount 到 /root
  sys_mount(name, "/root", fs, flags, data);
  sys_chdir("/root");

1.3.2.2.3. initrd_load

1.3.2.2.4. 为什么需要 initrd / initramfs

1.3.2.2.5. 为什么需要先 mount 一个 rootfs

1.3.3.3.1. 关于 follow_dotdot 最后的 follow_mount

$> mkdir -p a/b
$> mkdir c
$> mkdir d
$> sudo mount -o bind c a/b

$> cd a/b
$> stat ..
  File: '..'
  Size: 4096            Blocks: 8          IO Block: 4096   directory
Device: 802h/2050d      Inode: 21717951    Links: 3

$> sudo mount -o bind ~/d ~/a

$> stat ..
~/a/b@dell-work> stat ..
  File: '..'
  Size: 4096            Blocks: 8          IO Block: 4096   directory
Device: 802h/2050d      Inode: 21725293    Links: 2

1.3.9.1.1. d_revalidate

do_lookup:
  struct dentry *dentry = __d_lookup(nd->dentry, name);
  if (dentry->d_op && dentry->d_op->d_revalidate):
    goto need_revalidate;

need_revalidate:
  // d_revalidate 返回 1 表示 valid, 返回 0 表示 dentry 已经无效, 需要 real_lookup
  if (dentry->d_op->d_revalidate(dentry, nd)):
    goto done;
  d_invalidate(dentry)
  goto need_lookup;

need_lookup:
  dentry = real_lookup(nd->dentry, name, nd);

pid_revalidate:
  struct inode *inode = dentry->d_inode;
  struct task_struct *task = proc_task(inode)
  if (pid_alive(task)):
    return 1
  else:
    return 0

1.4.1.1.1. kern_mount

proc_get_sb:
  sb = type->get_sb(type, flags, name, data);
  // sb 的 root inode 是一个对应的 proc_root 这个 proc_dir_entry 的 inode
  // 主要的, 它的 i_op 和 i_fop 直接来自 proc_root
  sb->s_root = proc_get_inode(s, PROC_ROOT_INO, &proc_root)
  // iget 从 inodecache 时查找, 若没找到, 调用 alloc_inode
  inode = iget(sb, ino);
  if (de->proc_iops):
    inode->i_op = de->proc_iops;
  if (de->proc_fops):
    inode->i_fop = de->proc_fops;

1.4.1.1.2. proc_misc_init

proc_misc_init
  create_proc_read_entry("loadavg", 0, NULL, loadavg_read_proc, NULL);
  // ...
  proc_symlink("mounts", NULL, "self/mounts");
  create_seq_entry("cpuinfo", 0, &proc_cpuinfo_operations);
  // ...
  entry = create_proc_entry("kmsg", S_IRUSR, &proc_root);
  entry->proc_fops = &proc_kmsg_operations;

1. proc_dir_entry
   

   proc_dir_entry 相当于虚拟的 /proc 目录树中的结点

   struct proc_dir_entry {
       unsigned int low_ino;
       unsigned short namelen;
       const char *name;
       mode_t mode;
       nlink_t nlink;
       uid_t uid;
       gid_t gid;
       unsigned long size;
       struct inode_operations * proc_iops;
       struct file_operations * proc_fops;
       get_info_t *get_info;
       struct module *owner;
       struct proc_dir_entry *next, *parent, *subdir;
       void *data;
       read_proc_t *read_proc;
       write_proc_t *write_proc;
       atomic_t count;             /* use count */
       int deleted;                /* delete flag */
   };
   

   1. proc_root
      

      proc_root 这个特殊的 proc_dir_entry 对应于 "/proc":

      struct proc_dir_entry proc_root = {
          .low_ino    = PROC_ROOT_INO, 
          .namelen    = 5, 
          .name               = "/proc",
          .mode               = S_IFDIR | S_IRUGO | S_IXUGO, 
          .nlink              = 2, 
          .proc_iops  = &proc_root_inode_operations, 
          .proc_fops  = &proc_root_operations,
          .parent             = &proc_root,
      };
      

      上面的 do_kern_mount 可以看到, sb->mnt_root 这个 root inode 的主要信息都来自 proc_root

2. create_proc_entry
   

   create_proc_entry, 可以简单理解为: 以 hard code 的形式在内存中建立 /proc 目录树.

   create_proc_entry:
     ent = proc_create(&parent,name,mode,nlink);
     if (S_ISDIR(mode)):
       ent->proc_fops = &proc_dir_operations;
       ent->proc_iops = &proc_dir_inode_operations;
     proc_register(parent, ent)
       // inode number 是临时分配的
       i = get_inode_number();
       dp->low_ino = i;
       dp->next = dir->subdir;
       dp->parent = dir;
       dir->subdir = dp;
       if (S_ISDIR(dp->mode)):
         dp->proc_fops = &proc_dir_operations;
         dp->proc_iops = &proc_dir_inode_operations;
         dir->nlink++;
       else if (S_ISLNK(dp->mode)):
         if (dp->proc_iops == NULL):
           dp->proc_iops = &proc_link_inode_operations;
       else if (S_ISREG(dp->mode)):
         if (dp->proc_fops == NULL):
           dp->proc_fops = &proc_file_operations;
         if (dp->proc_iops == NULL):
           dp->proc_iops = &proc_file_inode_operations;
   

   create_proc_read_entry 和 create_seq_entry 都是对 create_proc_entry 的简单封装.

   1. proc_symlink
      

      proc_symlink 在 create_proc_entry 基础上, 将 symlink 的信息写到了 proc_dir_entry 的 data 部分

      struct proc_dir_entry *proc_symlink(const char *name, struct proc_dir_entry *parent, const char *dest):
        struct proc_dir_entry *ent;
        ent = proc_create(&parent,name,(S_IFLNK | S_IRUGO | S_IWUGO | S_IXUGO),1);
        ent->data = kmalloc((ent->size=strlen(dest))+1, GFP_KERNEL);
        strcpy((char*)ent->data,dest);
        proc_register(parent, ent)
          if (S_ISLNK(dp->mode)):
            dp->proc_iops = &proc_link_inode_operations;
      
      

3. xlate_proc_name
   

   通过 xlate_proc_name("/xxx/yyy") 可以找到 "/proc/xxx/yyy" 对应的 proc_dir_entry, 在 create_proc_entry 或后面的 proc_mkdir 时, 都会使用 xlate_proc_name

1.4.1.1.3. proc_mkdir

1.4.1.1.4. 总结

1.4.1.2.1. file_system_type

static struct file_system_type proc_fs_type = {
    .name               = "proc",
    .get_sb             = proc_get_sb,
    .kill_sb    = kill_anon_super,
};

1.4.1.2.2. file_system_type.get_sb

super_block *proc_get_sb(struct file_system_type *fs_type,...)
  return get_sb_single(fs_type, flags, data, proc_fill_super);

1.4.1.2.3. fill_super

int proc_fill_super(struct super_block *s, void *data, int silent)
  ...  
  s->s_magic = PROC_SUPER_MAGIC;
  s->s_op = &proc_sops;
  root_inode = proc_get_inode(s, PROC_ROOT_INO, &proc_root);
  s->s_root = d_alloc_root(root_inode);

1.4.1.2.4. super_operations

static struct super_operations proc_sops = { 
    .alloc_inode        = proc_alloc_inode,
    .destroy_inode      = proc_destroy_inode,
    .read_inode = proc_read_inode,
    .drop_inode = generic_delete_inode,
    .delete_inode       = proc_delete_inode,
    .statfs             = simple_statfs,
    .remount_fs = proc_remount,
};

1.4.1.2.5. i_op for /proc root

static struct inode_operations proc_root_inode_operations = {
        .lookup         = proc_root_lookup,
};

1.4.1.2.6. i_fop for /proc root

static struct file_operations proc_root_operations = {
.read            = generic_read_dir,
    .readdir     = proc_root_readdir,
};

1.4.1.2.7. i_fop for generic proc dir

static struct file_operations proc_dir_operations = {
    .read                       = generic_read_dir,
    .readdir            = proc_readdir,
};

1.4.1.2.8. i_op for generic proc dir

static struct inode_operations proc_dir_inode_operations = {
    .lookup             = proc_lookup,
    .setattr    = proc_notify_change,
};

1.4.1.2.9. i_fop for generic proc file

static struct file_operations proc_file_operations = {
    .llseek             = proc_file_lseek,
    .read               = proc_file_read,
    .write              = proc_file_write,
};

1.4.1.2.10. i_op for generic proc file

static struct inode_operations proc_file_inode_operations = {
        .setattr        = proc_notify_change,
};

1.4.1.2.11. 和 /proc/<pid> 相关的 i_op/i_fop

1.4.1.3.1. alloc_inode

static struct inode *proc_alloc_inode(struct super_block *sb):
  struct proc_inode *ei;
  struct inode *inode;
  ei = (struct proc_inode *)kmem_cache_alloc(proc_inode_cachep, SLAB_KERNEL);
  ei->task = NULL;
  ei->type = 0;
  ei->op.proc_get_link = NULL;
  ei->pde = NULL;
  inode = &ei->vfs_inode;
  inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
  return inode;

1.4.1.3.2. read_inode

1.4.1.3.3. statfs

1.4.1.4.1. lookup

1. proc_root_lookup
   

   /proc 根目录下本身的 lookup 函数

   proc_root_lookup
     // 首先查找非 <pid> 之类的 inode
     if (!proc_lookup(dir, dentry, nd)):
       return null
     // 若没有找到, 查找 <pid> 类型的 inode
     return proc_pid_lookup(dir, dentry, nd);
   

   1. proc_lookup
      

      /proc 一级目录下所有非 <pid> 的 inode 都是通过 proc_lookup 查找的. 具体的, 通过遍历之前通过 create_proc_entry 创建虚拟目录树来查找.

      proc_lookup(struct inode * dir, struct dentry *dentry, struct nameidata *nd):
        int error = -ENOENT;
        // dir 是 mnt_root, dentry 包括要查找的名字, nd 用来保存查找结果
        de = PDE(dir);
        for (de = de->subdir; de ; de = de->next):
          if (!memcmp(dentry->d_name.name, de->name, de->namelen)):
            unsigned int ino = de->low_ino;
            // proc_get_inode 基本就是将 proc_dir_entry 转换为相应的 inode
            inode = proc_get_inode(dir->i_sb, ino, de);
            break;
        if (inode):
          // 添加 <dentry, inode> 到 dcache,有了 dcache, 下次 lookup 时将不会再调用 proc_lookup
          d_add(dentry, inode);
          return null;
        // 若 lookup 失败, 返回 -ENOENT, 而不是返回 null
        return error; 
      

      因为 proc_lookup 时, 对于不存在的 inode 会返回 -ENOENT, 所以 /proc 根目录无法新建文件.

      /proc@dell-work> touch a
      touch: cannot touch 'a': No such file or directory
      

   2. proc_pid_lookup
      

      因为 /proc 下的 <pid> 之类的 inode 是动态变化的, 无法通过 create_proc_entry 添加到虚拟的 /proc 目录树中, 所以需要通过 proc_pid_lookup 动态去查找

      proc_pid_lookup
        if (dentry->d_name.len == 4 && !memcmp(dentry->d_name.name,"self",4)):
          // inode 的 ino 为 last_ino++ 
          inode = new_inode(dir->i_sb);
          inode->i_op = &proc_self_inode_operations;
          d_add(dentry, inode);
          return null;
        tgid = name_to_int(dentry);
        task = find_task_by_pid(tgid);
        inode = proc_pid_make_inode(dir->i_sb, task, PROC_TGID_INO);
          // new_inode 是 vfs 通用接口, 但它会调用到 sb 中的 alloc_inode, 具体的
          // proc_alloc_inode 会生成一个 proc_inode, 并返回其中的 vfs_inode,
          // 这也就是下面 PROC_I 的意义: proc_inode 在 inode 基础上附加了一些和
          // proc 自身相关的信息, 例如 task
          inode = new_inode(sb);
          struct proc_inode ei = PROC_I(inode);
            container_of(inode, struct proc_inode, vfs_inode);
        inode->i_op = &proc_tgid_base_inode_operations;
        inode->i_fop = &proc_tgid_base_operations;
        d_add(dentry, inode);
      

2. proc_tgid_base_lookup
   

   /proc/<pid> 目录的 lookup 函数

   上一步的 proc_pid_lookup 函数负责将 /proc/<pid> inode 的 i_op 赋值为 proc_tgid_base_inode_operations, 后者的定义为:

   static struct inode_operations proc_tgid_base_inode_operations = {
           .lookup         = proc_tgid_base_lookup,
   };
   

   其中 proc_tgid_base_lookup 是 /proc/<pid> 的 lookup 函数

   static struct pid_entry tgid_base_stuff[] = {
       E(PROC_TGID_TASK,      "task",    S_IFDIR|S_IRUGO|S_IXUGO),
       E(PROC_TGID_FD,        "fd",      S_IFDIR|S_IRUSR|S_IXUSR),
       E(PROC_TGID_ENVIRON,   "environ", S_IFREG|S_IRUSR),
       E(PROC_TGID_AUXV,      "auxv",        S_IFREG|S_IRUSR),
       E(PROC_TGID_STATUS,    "status",  S_IFREG|S_IRUGO),
       E(PROC_TGID_CMDLINE,   "cmdline", S_IFREG|S_IRUGO),
       E(PROC_TGID_STAT,      "stat",    S_IFREG|S_IRUGO),
       E(PROC_TGID_STATM,     "statm",   S_IFREG|S_IRUGO),
       // ...
   }
   

   struct dentry *proc_tgid_base_lookup(inode *dir, dentry *dentry, nameidata *nd):
     // dir 代表 /proc/<pid> 这个 inode, 其对应的 proc_inode 包括对应的 task
     // 可以对应到一个进程
     // dentry 包括要查找的名字
     // nd 返回查找结果
     // tgid_base_stuff 是一个 hard code 的数组  
     proc_pident_lookup(dir, dentry, tgid_base_stuff);
       struct task_struct *task = proc_task(dir);
       // ents 即 tgid_base_stuff
       for (p = ents; p->name; p++):
         if (!memcmp(dentry->d_name.name, p->name, p->len)):
           break;
       inode = proc_pid_make_inode(dir->i_sb, task, p->type);
         inode = new_inode(sb);
         inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
         inode->i_ino = fake_ino(task->pid, ino);
         ei = PROC_I(inode);
         // 这里的 task 赋值很重要, 它标识了这个 inode, 后面针对这个 inode 的回调
         // 一般都需要这个 task, 比如 proc_lookupfd 
         ei->task = task;
         ei->type = ino;
         inode->i_uid = 0;
         inode->i_gid = 0;
       switch(p->type):
         case PROC_TGID_TASK:
           inode->i_op = &proc_task_inode_operations;
           inode->i_fop = &proc_task_operations;
         case PROC_TID_FD:
           inode->i_op = &proc_fd_inode_operations;
           inode->i_fop = &proc_fd_operations;
         // ...
       d_add(dentry, inode);
   

1.4.1.4.2. permission

1.4.1.4.3. readlink

1. /proc/self
   

   struct dentry * proc_pid_lookup:
     if (dentry->d_name.len == 4 && !memcmp(dentry->d_name.name,"self",4)):
       inode = new_inode(dir->i_sb);
       inode->i_mode = S_IFLNK|S_IRWXUGO;
       inode->i_op = &proc_self_inode_operations;
       // ...
   

   proc_self_readlink(struct dentry *dentry, char __user *buffer,int buflen):
       char tmp[30];
       sprintf(tmp, "%d", current->tgid);
       return vfs_readlink(dentry,buffer,buflen,tmp);
   

2. /proc/<pid>/fd/<fd>
   

   proc_lookupfd:
     // 该 inode 对应 /proc/<pid>/fd/<fd>, 其对应的 fd 被编码到 proc_inode->type 中
     inode = proc_pid_make_inode(dir->i_sb, task, PROC_TID_FD_DIR+fd);
     inode->i_mode = S_IFLNK;
     // 后续 proc_pid_link_inode_operations->readlink 会调用 proc_fd_link 得到 symlink 的数据
     inode->i_op = &proc_pid_link_inode_operations;
     ei->op.proc_get_link = proc_fd_link;
   

   proc_fd_link:
     struct task_struct *task = proc_task(inode);
     int fd = proc_type(inode) - PROC_TID_FD_DIR;
     files = get_files_struct(task);
     file = fcheck_files(files, fd);
       return files->fd[fd];
     *mnt = mntget(file->f_vfsmnt);
     *dentry = dget(file->f_dentry);
   

3. /proc/mounts
   

   proc_root_init 时, 通过 proc_symlink 建立了一个 proc_dir_entry , 这个 entry 是 /proc/mounts 到 /proc/self/mounts 的 symlink, 具体参考前面 proc_symlink

   proc_follow_link:
     // symlink 的 target 保存在 proc_inode->data 中
     nd_set_link(nd, PDE(dentry->d_inode)->data);
       nd->saved_names[nd->depth] = path;
   
   generic_readlink:
     res = dentry->d_inode->i_op->follow_link(dentry, &nd);
     res = vfs_readlink(dentry, buffer, buflen, nd_get_link(&nd));
       return nd->saved_names[nd->depth];
   

1.4.1.5.1. readdir

1.5.2.1.1. dir

1. 新建空目录
   

   ext2_mkdir:
     inode = ext2_new_inode (dir, S_IFDIR | mode);
     ext2_make_empty(inode, dir);
       chunk_size = ext2_chunk_size(inode);
         // s_blocksize 与 fs 的配置有关, 一般为 4K
         return inode->i_sb->s_blocksize;
       ext2_commit_chunk(page, 0, chunk_size);
         // from 为 0, to 为 chunk_size (4K)
         page->mapping->a_ops->commit_write(NULL, page, from, to);
           generic_commit_write(file, page, from, to)
             // inode->i_size 初始为 0
             if (pos > inode->i_size):
               i_size_write(inode, pos);
                 // I GOT YOU! 新建目录大小为 4K
                 inode->i_size = i_size;
               mark_inode_dirty(inode);
     // 修改新建目录的父目录, 早期版本的 linux 称为 ext2_add_entry
     ext2_add_link(dentry, inode);
   

2. 目录中添加文件或子目录导致大小变化
   

   ext2_create:
     ext2_add_nondir(dentry, inode);
       ext2_add_link(dentry, inode);
   

   ext2_add_link:
     from = (char*)de - (char*)page_address(page);
     // rec_len 和 entry 的名字长度有关
     to = from + rec_len;
     ext2_commit_chunk(page, from, to);
   

1.5.2.1.2. symlink

ext2_symlink:
  l = strlen(symname)+1;
  if (l > sizeof (EXT2_I(inode)->i_data)):
    struct ext2_inode_info {
      __le32    i_data[15];
      // ...
    }
    // 若 symname 长度大于 60 (15*4), 则使用 slow symlink
    // 所谓 slow symlink, 是指使用 data block 来保存 symname
    page_symlink(inode, symname, l);
    mapping->a_ops->commit_write(NULL, page, 0, len-1);
  else:
    // fast symlink, symname 被保存在 i_data 中
    memcpy((char*)(EXT2_I(inode)->i_data),symname,l);
    inode->i_size = l-1;

~@dell-work> ln -s "123456789012345678901234567890123456789012345678901234567890" a

~@dell-work> stat a
  File: 'a' -> '123456789012345678901234567890123456789012345678901234567890'
  Size: 60              Blocks: 8          IO Block: 4096   symbolic link
Device: 802h/2050d      Inode: 21500456    Links: 1

~@dell-work> rm a
rm: remove symbolic link 'a'? y

~@dell-work> ln -s "12345678901234567890123456789012345678901234567890123456789" a

~@dell-work> stat a
  File: 'a' -> '12345678901234567890123456789012345678901234567890123456789'
  Size: 59              Blocks: 0          IO Block: 4096   symbolic link
Device: 802h/2050d      Inode: 21500456    Links: 1

ext2_read_inode:
  if (S_ISLNK(inode->i_mode)):
    if (ext2_inode_is_fast_symlink(inode)):
      inode->i_op = &ext2_fast_symlink_inode_operations;
    else:
      inode->i_op = &ext2_symlink_inode_operations;

ext2_inode_is_fast_symlink:
  int ea_blocks = EXT2_I(inode)->i_file_acl ? (inode->i_sb->s_blocksize >> 9) : 0;
  return (S_ISLNK(inode->i_mode) && inode->i_blocks - ea_blocks == 0;)

1.5.2.1.3. regular file

1.5.2.1.4. char/blk device

1.5.2.1.5. fifo

1.5.2.1.6. socket