I was wondering why an empty directory occupied 4096 bytes of space and I have seen this question. It is stated that space is allocated in blocks and hence, the size of a new directory is 4096 bytes.
However I am pretty sure that allocation for "normal" files are done in blocks as well. At least it is like that in Windows filesystems and I am guessing that it must be at least similar in ext*.
Now as far as I understood, size listing for other types of files, such as files, symbolic links etc. are done in terms of real size. Because when I create an empty file, I see a 0 as the size. When a type a few characters, I see the < number of characters > bytes as the size etc.
So my question is, although the allocation for other files are done in blocks too, why the policy for reporting the size of a directory and a file differs?
I thought the question was clear enough but apparently is wasn't. I will try to clarify the question here.
1) What I think a directory is:
I will try to explain what I think a directory is by the following example. After reading, if it is wrong, please notify me.
Let's say that we have a directory named
mydir. And let's say that it contains 3 files, which are:
f2. Let's assume that each file is 1 byte long.
Now, what is
mydir? It is a pointer to an inode which contains the following: String "f0" and the inode number which
f0 points to. String "f1" and the inode number which
f1 points to. And string "f2" and the inode number which
f2 points to. (At least this is what I think a directory is. Please correct me if I am wrong.)
Now there may be two methods for calculating the size of a directory:
1) Calculating the size of the inode which
mydir points to.
2) Summing the sizes of the inodes which contents of
mydir points to.
Although 1 is more counter intuitive, let's assume that it is the method that is being used. (For this question, which method is the method that is actually being used does not matter.) Then, the size of
mydir is calculated as the following:
2 + 2 + 2 + 3 * <space_required_to_store_an_inode_number>
2's are because each filename is 2 bytes long.
2) The question:
Now the question: Assuming what I think a directory is correct, the reported size for
mydir should be much much less than 4096, no matter method 1 or method 2 is being used to calculate its size.
Now, you will say that the reason it is reported 4096 bytes is because the allocation is done in blocks. Hence, the reported size that big.
But then I will say: Allocation is done in blocks for regular files as well. (See thrig's answer for reference) But nevertheless, their sizes are reported in real sizes. (1 byte if they contain 1 character, 2 bytes if they contain 2 characters etc.)
So my question is, why is the policy for reporting sizes of directories is such different than reporting sizes of regular files?
We know that the initial number of blocks allocated for a non-empty file and for an empty directory is both 8 blocks. (See thrig's answer) So even though allocation is made in the same number of blocks for both regular files and directories, why the reported size for a directory is much bigger?