Before you can understand moving and copying files, you need to know a bit more about how files are represented in directories. What does it mean to say that a file is really "in" a directory? It's easy to imagine that files are actually inside of something (some special chunk of the disk that's called a directory). But that's precisely wrong, and it's one place where the of a filesystem doesn't apply.
A directory really is just another file, and really isn't different
from any other data file.
If you want to prove this, try the command
od -c .; on many UNIX systems,
it dumps the current directory to the screen in raw form.
It will certainly look ugly (it's not a text file - it has lots
of binary characters).
But, if your system allows it,
should let you see the names of the files that are in
the current directory
[and, probably, some names of files that have been deleted!
Sorry, they're only the old directory entries;
If od -c doesn't work, use
ls -if instead.
So a directory is really just a list of files. It contains filenames and. That is, we can visualize a directory like this:
The file named . is inode 34346 The file named .. is inode 987 The file named mr.ed is inode 10674 The file named joe.txt is inode 8767 The file named grok is inode 67871 The file named otherdir is inode 2345
So when you give a filename like grok, the kernel looks up grok in the current directory and finds out that this file has inode 67871; it looks up this inode to find out who owns the file, where the data blocks are, and so on.
What's more, some of these "files" may be directories in their own
right. In particular, that's true of the first two entries:
... These entries are in every directory.
. just refers to the current directory, while double
refers to the "parent" of the current directory (i.e., the directory
that "contains" the current directory). The file otherdir is
yet another directory that happens to be "within" the current directory.
But there's no way you can tell that from its directory entry-UNIX
doesn't know it's different until it looks up its inode.
Now that you know what a directory is, let's think about some basic operations. What does it mean to move, or rename, a file? If the file is staying in the same directory, the mv command just changes the file's name in the directory; it doesn't touch the data at all.
Moving a file into another directory takes a little more work, but not much. A command like mv dir1/foo dir2/foo means "delete foo's entry in dir1, and create a new entry for foo in dir2." Again, UNIX doesn't have to touch the data blocks or the inode at all.
The only time you actually need to copy data is if you're moving a file into another filesystem. In that case, you have to copy the file to the new filesystem; delete its old directory entry; return the file's data blocks to the "free list," which means that they can be re-used; and so on. It's a fairly complicated operation, but (still) relatively rare. (On some old versions of UNIX, mv won't let you move files between filesystems.)
Now let's see if you've understood. How does UNIX find out the name of
the current directory? In our "current directory," there's an entry
., which tells us that the current directory has inode
34346. Is the directory's name part of the inode? Sorry - it isn't.
The directory's name is included in the parent directory. The
parent directory is
.., which is inode 987. So UNIX looks up
inode 987, finds out where the data is, and starts reading every entry
in the parent directory. Sooner or later, it will find one that
corresponds to inode 34346. When it does that, it knows that it has found the
directory entry for the current directory, and can read its name.
has a diagram and more explanation.
Complicated? Yes, but if you understand this, you have a pretty good idea of how UNIX directories work.