statfsシステムコールはファイルのファイルシステム情報を取得します。ファイルシステムの情報はデバイスのスーパブロックに設定されてり、実装はファイルのスーパブロックコールバックの.statfsをコールする事で行います。

SYSCALL_DEFINE2(statfs, const char __user *, pathname, struct statfs __user *, buf)
{
       struct kstatfs st;
       int error = user_statfs(pathname, &st);
       if (!error)
               error = do_statfs_native(&st, buf);
       return error;
}

int user_statfs(const char __user *pathname, struct kstatfs *st)
{
       struct path path;
       int error = user_path_at(AT_FDCWD, pathname, LOOKUP_FOLLOW|LOOKUP_AUTOMOUNT, &path);
       if (!error) {
               error = vfs_statfs(&path, st);
               path_put(&path);
       }
       return error;
}

int vfs_statfs(struct path *path, struct kstatfs *buf)
{
       int error;

       error = statfs_by_dentry(path->dentry, buf);
       if (!error)
               buf->f_flags = calculate_f_flags(path->mnt);
       return error;
}

static int statfs_by_dentry(struct dentry *dentry, struct kstatfs *buf)
{
       int retval;

       if (!dentry->d_sb->s_op->statfs)
               return -ENOSYS;

       memset(buf, 0, sizeof(*buf));
       retval = security_sb_statfs(dentry);
       if (retval)
               return retval;
       retval = dentry->d_sb->s_op->statfs(dentry, buf);
       if (retval == 0 && buf->f_frsize == 0)
               buf->f_frsize = buf->f_bsize;
       return retval;
}

ext2_statfs()はext2のスーパブロックオペレーションのstatfsコールバックです。dentryから取得したスーパブロック情報をstruct kstatfs * bufに設定します。

MINIX_DFはextファイルシステムのmountでのオプションです。設定されていれば、トータルブロックをブロックグループ/inodeマップブロック等のブロックを管理するためのブロックもカウントされますが、設定されていなければこれらのブロックはカウントされません。実際の使用可能ブロック数となります。

struct ext2_super_blockは物理デバイスのラージインディアンのイメージが設定され、le32_to_cpu()でシステムに依存したインディアンで設定する必要があります。

static int ext2_statfs (struct dentry * dentry, struct kstatfs * buf)
{
       struct super_block *sb = dentry->d_sb;
       struct ext2_sb_info *sbi = EXT2_SB(sb);
       struct ext2_super_block *es = sbi->s_es;
       u64 fsid;

       spin_lock(&sbi->s_lock);

       if (test_opt (sb, MINIX_DF))
               sbi->s_overhead_last = 0;
       else if (sbi->s_blocks_last != le32_to_cpu(es->s_blocks_count)) {
               unsigned long i, overhead = 0;
               smp_rmb();

               overhead = le32_to_cpu(es->s_first_data_block);

               for (i = 0; i < sbi->s_groups_count; i++)
                       overhead += ext2_bg_has_super(sb, i) +
                               ext2_bg_num_gdb(sb, i);


               overhead += (sbi->s_groups_count *
                            (2 + sbi->s_itb_per_group));
               sbi->s_overhead_last = overhead;
               smp_wmb();
               sbi->s_blocks_last = le32_to_cpu(es->s_blocks_count);
       }

       buf->f_type = EXT2_SUPER_MAGIC;
       buf->f_bsize = sb->s_blocksize;
       buf->f_blocks = le32_to_cpu(es->s_blocks_count) - sbi->s_overhead_last;
       buf->f_bfree = ext2_count_free_blocks(sb);
       es->s_free_blocks_count = cpu_to_le32(buf->f_bfree);
       buf->f_bavail = buf->f_bfree - le32_to_cpu(es->s_r_blocks_count);
       if (buf->f_bfree < le32_to_cpu(es->s_r_blocks_count))
               buf->f_bavail = 0;
       buf->f_files = le32_to_cpu(es->s_inodes_count);
       buf->f_ffree = ext2_count_free_inodes(sb);
       es->s_free_inodes_count = cpu_to_le32(buf->f_ffree);
       buf->f_namelen = EXT2_NAME_LEN;
       fsid = le64_to_cpup((void *)es->s_uuid) ^
              le64_to_cpup((void *)es->s_uuid + sizeof(u64));
       buf->f_fsid.val[0] = fsid & 0xFFFFFFFFUL;
       buf->f_fsid.val[1] = (fsid >> 32) & 0xFFFFFFFFUL;
       spin_unlock(&sbi->s_lock);
       return 0;
}

do_statfs_native()でuser_statfs()で取得したstruct kstatfs *stを、struct statfs __user *pに設定するのですが、kstatfsはカーネルの、statfsはユーザプロセスの構造体です。kstatfsはプラットホーム(32/64ビット)に関係なく、f_blocks等のサイズは64ビット固定ですが、statfsはプラットホームによりlongサイズを32ビットとするケースもあり、従ってkstatfsの掛かるメンバ値が、32ビットを超えていないかチェックする必要があります。

st->f_files != -1/st->f_ffree != -1は、ファイルが作成できない等のマジックコードとして設定でもされるのかと思いましたが、そうでなさく、4/8バイトの違いはあれど、statfsも-1となるわけで、結果が-1なら8バイトとしての最大値と言うことです。

#if __BITS_PER_LONG == 64
#define __statfs_word long
#else
#define __statfs_word __u32
#endif

struct kstatfs {
       long f_type;
       long f_bsize;
       u64 f_blocks;
       u64 f_bfree;
       u64 f_bavail;
       u64 f_files;
       u64 f_ffree;
       __kernel_fsid_t f_fsid;
       long f_namelen;
       long f_frsize;
       long f_flags;
       long f_spare[4];
};

struct statfs {
       __statfs_word f_type;
       __statfs_word f_bsize;
       __statfs_word f_blocks;
       __statfs_word f_bfree;
       __statfs_word f_bavail;
       __statfs_word f_files;
       __statfs_word f_ffree;
       __kernel_fsid_t f_fsid;
       __statfs_word f_namelen;
       __statfs_word f_frsize;
       __statfs_word f_flags;
       __statfs_word f_spare[4];
};

static int do_statfs_native(struct kstatfs *st, struct statfs __user *p)
{
       struct statfs buf;

       if (sizeof(buf) == sizeof(*st))
               memcpy(&buf, st, sizeof(*st));
       else {
               if (sizeof buf.f_blocks == 4) {
                       if ((st->f_blocks | st->f_bfree | st->f_bavail |
                            st->f_bsize | st->f_frsize) &
                           0xffffffff00000000ULL)
                               return -EOVERFLOW;

                       if (st->f_files != -1 &&
                           (st->f_files & 0xffffffff00000000ULL))
                               return -EOVERFLOW;
                       if (st->f_ffree != -1 &&
                           (st->f_ffree & 0xffffffff00000000ULL))
                               return -EOVERFLOW;
               }

               buf.f_type = st->f_type;
               buf.f_bsize = st->f_bsize;
               buf.f_blocks = st->f_blocks;
               buf.f_bfree = st->f_bfree;
               buf.f_bavail = st->f_bavail;
               buf.f_files = st->f_files;
               buf.f_ffree = st->f_ffree;
               buf.f_fsid = st->f_fsid;
               buf.f_namelen = st->f_namelen;
               buf.f_frsize = st->f_frsize;
               buf.f_flags = st->f_flags;
               memset(buf.f_spare, 0, sizeof(buf.f_spare));
       }
       if (copy_to_user(p, &buf, sizeof(buf)))
               return -EFAULT;
       return 0;
}

ustatシステムコールの実装はstatfsシステムコールと同じで、スーパブロックのstatfsコールバックをコールします。ただ取得する情報がf_bfree/f_ffreeとしているだけです。たぶん他のシステムとの互換性(他のシステム下でのアプリ)のためではと思います。

SYSCALL_DEFINE2(ustat, unsigned, dev, struct ustat __user *, ubuf)
{
       struct ustat tmp;
       struct kstatfs sbuf;
       int err = vfs_ustat(new_decode_dev(dev), &sbuf);
       if (err)
               return err;

       memset(&tmp,0,sizeof(struct ustat));
       tmp.f_tfree = sbuf.f_bfree;
       tmp.f_tinode = sbuf.f_ffree;

       return copy_to_user(ubuf, &tmp, sizeof(struct ustat)) ? -EFAULT : 0;
}

int vfs_ustat(dev_t dev, struct kstatfs *sbuf)
{
       struct super_block *s = user_get_super(dev);
       int err;
       if (!s)
               return -EINVAL;

       err = statfs_by_dentry(s->s_root, sbuf);
       drop_super(s);
       return err;
}

補足

・MINIX_DFオプションは、statfsコールバックのみで参照され、本オプションにより使用可能ブロック量にまったく影響されません。
・ブロックグループは、extは全ブロックを論理的に分割し、グループ単位でinodeマップ等を管理する事でブロックのフラグメンテーションを最小化するための物です。