dfとdf -hが異なる値を表示するのはなぜですか？ df -hはどのように計算されますか？

df -hは正確にどのように機能しますか？を実行すると、df次のような結果が得られます。

Filesystem     1K-blocks    Used Available Use% Mounted on
/dev/simfs      41943040 7659828  34283212  19% /

を実行すると、df -h次のような結果が得られます。

Filesystem      Size  Used Avail Use% Mounted on
/dev/simfs       40G  7.4G   33G  19% /

問題は同じ番号を取得する方法です。

41943040/1024/1024 = 40 文字、残りを 1024 で割りましょう。

7659828 / 1024 / 1024 = 7,304981

だからおそらく1000？

7659828 / 1000 / 1000 = 7,659828

df -h7.4Gはどのように誕生しましたか？

34283212 / 1024 / 1024 = 32,695, which is ±33G

dfはオープンソースですが、複製再購入してコードを確認しました。これが私が見つけたものです：

for (col = 0; col < ncolumns; col++)
    {
      char *cell = NULL;
      char const *header = _(columns[col]->caption);

      if (columns[col]->field == SIZE_FIELD
          && (header_mode == DEFAULT_MODE
              || (header_mode == OUTPUT_MODE
                  && !(human_output_opts & human_autoscale))))
        {
          char buf[LONGEST_HUMAN_READABLE + 1];

          int opts = (human_suppress_point_zero
                      | human_autoscale | human_SI
                      | (human_output_opts
                         & (human_group_digits | human_base_1024 | human_B)));

          /* Prefer the base that makes the human-readable value more exact,
             if there is a difference.  */

          uintmax_t q1000 = output_block_size;
          uintmax_t q1024 = output_block_size;
          bool divisible_by_1000;
          bool divisible_by_1024;

          do
            {
              divisible_by_1000 = q1000 % 1000 == 0;  q1000 /= 1000;
              divisible_by_1024 = q1024 % 1024 == 0;  q1024 /= 1024;
            }
          while (divisible_by_1000 & divisible_by_1024);

          if (divisible_by_1000 < divisible_by_1024)
            opts |= human_base_1024;
          if (divisible_by_1024 < divisible_by_1000)
            opts &= ~human_base_1024;
          if (! (opts & human_base_1024))
            opts |= human_B;

          char *num = human_readable (output_block_size, buf, opts, 1, 1);

          /* Reset the header back to the default in OUTPUT_MODE.  */
          header = _("blocks");

          /* TRANSLATORS: this is the "1K-blocks" header in "df" output.  */
          if (asprintf (&cell, _("%s-%s"), num, header) == -1)
            cell = NULL;
        }
      else if (header_mode == POSIX_MODE && columns[col]->field == SIZE_FIELD)
        {
          char buf[INT_BUFSIZE_BOUND (uintmax_t)];
          char *num = umaxtostr (output_block_size, buf);

          /* TRANSLATORS: this is the "1024-blocks" header in "df -P".  */
          if (asprintf (&cell, _("%s-%s"), num, header) == -1)
            cell = NULL;
        }
      else
        cell = strdup (header);

      if (!cell)
        xalloc_die ();

      hide_problematic_chars (cell);

      table[nrows - 1][col] = cell;

      columns[col]->width = MAX (columns[col]->width, mbswidth (cell, 0));
    }

私はこの言語の経験を持っていませんが、私が理解したように、各列の値が1024または1000で割ることができることを確認し、オプションの値をレンダリングするためのより良いものを選択します-h。しかし、1000または1024で割っても同じ値は出ません。なぜ？

なぜそうなのか分かると思います。 1000 または 1024 で割ったことを確認します。各分配する

          if (divisible_by_1000 < divisible_by_1024)
            opts |= human_base_1024;
          if (divisible_by_1024 < divisible_by_1000)
            opts &= ~human_base_1024;
          if (! (opts & human_base_1024))
            opts |= human_B;

それでは7659828/1024/1024=7,304981を解読しましょう。-h答えを与えた7.4G

7659828 / 1024 = 7480,xxx
7659828 / 1000 = 7659,xxx

7659 は、7480 を 1024 で割った値です。

数字はまだ途方もないです。続けてみましょう。

7659828 / 1024 / 1024 = 7,xxx  (7,3049..)
7659828 / 1024 / 1000 = 7,xxx  (7,4803..)

今1000が必要で、7,48が与えられたら信じるコードのどこかに「多くより少なく話す方が良い」と丸められ、7.4Gのデータを入れることができますが、7.5Gは入れることができません。

33.4Gも状況は同じです

34283212 / 1024 / 1000 = 33.47...

それで33Gになりました。