What Are the Underlying Protocols/Standards a “Windows File Path” as Opposed to a NFS-Like Linux File Path? [closed]

Question

This is probably a very poorly worded question, but the taxonomy of this question is what I'm looking for (so unfortunately at this point I can't help it).

Here is my question.

We don't walk around calling the file system representation for Centos "Centos File Paths", likewise we don't call the file system in Ubuntu "Ubuntu File Paths" or even "Linux File Paths" - I typically see these referred to as NFS paths (whether this is correct or not).

I do hear Windows users refer to the file system representation (with drive letters) as "Windows file paths". So I guess I'm asking "What exactly is a Windows File path"? By this, I mean what are the underlying concepts and protocols that govern what a Windows file path is.

For further clarity, here are some examples. To my understanding, what I refer to as a NFS path (whether this is correct or incorrect) looks like this:

/etc/some-other-dir

where each level/dir is divided by /

My naive taxonomy for "Windows path" looks something like:

c:\some-dir\some-child-dir

So by default, when I jump onto one of the various Linux variants I use (Centos, Ubuntu) I usually refer to this as an NFS path. When I hop onto Windows, I call it a "Windows Path". I realize there are protocols and standards which probably govern this file system mapping (e.g. what maps c:\some-dir to sections of a disk), and Google has pointed me to CIFS/SMB described here: http://en.wikipedia.org/wiki/Cifs

But this seems to describe Windows network paths. I also saw the "drive naming scheme" here - http://en.wikipedia.org/wiki/DOS#Drive_naming_scheme - but this doesn't really answer my question. When I jump on my Windows machine, what exactly makes a Windows path? Specifically, when I specify c:\some-dir\some-child-dir, what protocols and standards are being used by the operating system to point this address to part of my hard-drive? Let's assume we're talking about Windows 7 (although I'd also be interested to know if Windows 7 does this differently from other versions of Windows).

I realize this is probably noob question and the answer is probably very easy to find with the correct keywords, but the frustration of not knowing is starting to get to me.

No "Just Google it" answers please - I have done this extensively and it just seems to raise further questions. I'm looking for a technical explanation here.

Answer 1

Just about every modern system uses a filesystem supporting a hierarchical structure -- some base level, with folders containing more folders (and so on), some of them with files in them.

The choice of the character used in the interface to tell you where you are is pretty arbitrary; UNIX-based systems use forward slash (/), DOS-derived ones used backslash (\) -- MSDN has some background on that choice -- while pre-OSX Macs used colon (:)

DOS (and descendents, up until NT) gave all the physical drive devices (and things that fake them) single-letter identifiers. Originally there was room for 2 floppy drives (A: and B:), so the hard drive became C:, and stayed that way by tradition (to the point that a shocking number of programs break if you change your boot drive's letter.)

In NT, they did away with most of the behind-the-scenes requirements for having the drive be C:, and added the ability to mount another physical drive as a directory under C:. This puts it more in line with the UNIX way of things: the boot drive is mounted as '/', and various other drives can be mounted as folders underneath it (/home, /usr, /tmp, whatever you like).

When DOS discovered networks, they got rid of drive letters for remote devices, getting you a UNC-style path: \servername\share\folder\file.txt. The share is just a name for the base directory on the server side, and it's pretty typical for the share name to match the name of the top-level directory of the share, but not a requirement.

When you stay UNIX-to-UNIX or Windows-to-Windows, it's simple, just keep slash-versus-backslash the same everywhere, and you're set. When you cross over, things get messy. Most programs stick with the syntax for the platform they're running on, even when they are (likely unknowingly) accessing something from the other platform. Some apps -- specifically written for cross-platform compatibility or attempts at user-friendly ness -- like their inputs in the intended format for the other platform. This gets messy: UNIX shells use backslash as the escape char; you need to type '\\' to get a single backslash sent as input to a UNIX command as a command-line option.

All that, of course, is mostly user-interface stuff. Behind the sceens, a file is really identified by (basically) a number (UNIX systems call it an inode), and the file system is responsible for tracking which names (possibly multiple, in different directories, in the case of hard links) map to the same inode, and which disk sectors are the content of the same inode).