Page 385 - DCAP103_Principle of operating system
P. 385

Principles of Operating Systems



                   Notes         read-only file systems for CD-ROMs and DVDs. It is possible (even common) to have the same
                                 running system have access to multiple file system types available at the same time.
                                 In this unit, we will treat the NTFS file system because it is a modern file system unencumbered
                                 by the need to be fully compatible with the MS-DOS file system, which was based on the CP/M
                                 file system designed for 8-inch floppy disks more than 20 years ago. Times have changed and
                                 8-inch floppy disks are not quite state of the art any more. Neither are their file systems. Also,
                                 NTFS differs both in user interface and implementation in a number of ways from the UNIX file
                                 system, which makes it a good second example to study. NTFS is a large and complex system
                                 and space limitations prevent us from covering all of its features, but the material presented
                                 below should give a reasonable impression of it.
                                 13.2.1 Fundamental Concepts of Windows 2000 File System

                                 Individual  file  names  in  NTFS  are  limited  to  255  characters;  full  paths  are  limited  to  32,767
                                 characters. File names are in Unicode, allowing people in countries not using the Latin alphabet
                                 (e.g., Greece, Japan, India, Russia, and Israel) to write file names in their native language. For
                                 example, τλ∈ is a perfectly legal file name. NTFS fully supports case sensitive names (so foo is
                                 different from Foo and FOO). Unfortunately, the Win32 API does not fully support case-sensitivity
                                 for file names and not at all for directory names, so this advantage is lost to programs restricted
                                 to using Win32 (e.g., for Windows 98 compatibility).
                                 An NTFS file is not just a linear sequence of bytes, as FAT-32 and UNIX files are. Instead, a
                                 file consists of multiple attributes, each of which is represented by a stream of bytes. Most files
                                 have a few short streams, such as the name of the file and its 64-bit object ID, plus one long
                                 (unnamed) stream with the data. However, a file can also have two or more (long) data streams
                                 as well. Each stream has a name consisting of the file name, a colon, and the stream name, as in
                                 foo:stream1. Each stream has its own size and is lockable independently of all the other streams.
                                 The idea of multiple streams in a file was borrowed from the Apple Macintosh, in which files
                                 have two streams, the data fork and the resource fork. This concept was incorporated into NTFS
                                 to allow an NTFS server be able to serve Macintosh clients.

                                 File streams can be used for purposes other than Macintosh compatibility. For example, a photo
                                 editing program could use the unnamed stream for the main image and a named stream for a
                                 small thumbnail version. This scheme is simpler than the traditional way of putting them in the
                                 same file one after another. Another use of streams is in word processing. These programs often
                                 make two versions of a document, a temporary one for use during editing and a final one when
                                 the user is done. By making the temporary one a named stream and the final one the unnamed
                                 stream, both versions automatically share a file name, security information, timestamps, etc.
                                 with no extra work.
                                 The maximum stream length is 2  bytes. To get some idea of how big a 2 -byte stream is, imagine
                                                           64
                                                                                          64
                                 that the stream were written out in binary, with each of the 0s and 1s in each byte occupying
                                 1 mm of space. The 2 -mm listing would be 15 light-years long, reaching far beyond the solar
                                                   67
                                 system, to Alpha Centauri and back. File pointers are used to keep track of where a process
                                 is in each stream, and these are 64 bits wide to handle the maximum length stream, which is
                                 about 18.4 exabytes.

                                 The Win32 API function calls for file and directory manipulation are roughly similar to their
                                 UNIX  counterparts,  except  most  have  more  parameters  and  the  security  model  is  different.
                                 Opening a file returns a handle, which is then used for reading and writing the file. For graphical
                                 applications, no file handles are predefined. Standard input, standard output, and standard error
                                 have to be acquired explicitly if needed; in console mode they are preopened, however, Win32
                                 also has a number of additional calls not present in UNIX.



        378                               LOVELY PROFESSIONAL UNIVERSITY
   380   381   382   383   384   385   386   387   388   389   390