Distributed File Systems

MEDI-CAPS UNIVERSITY
Faculty of Engineering
Mr. Sagar Pandya
Information Technology Department
sagar.pandya@medicaps.ac.in

Distributed System
Mr. Sagar Pandya
Information Technology Department
Course
Code
Course Name Hours Per
Week
Total Hrs. Total
Credits
L T P
IT3EL04 Distributed System 3 0 0 3 3

Reference Books
 Text Book:
1. G. Coulouris, J. Dollimore and T. Kindberg, Distributed Systems: Concepts
and design, Pearson.
2. P K Sinha, Distributed Operating Systems: Concepts and design, PHI
Learning.
3. Sukumar Ghosh, Distributed Systems - An Algorithmic approach, Chapman
and Hall/CRC
 Reference Books:
1. Tanenbaum and Steen, Distributed systems: Principles and Paradigms,
Pearson.
2. Sunita Mahajan & Shah, Distributed Computing, Oxford Press.
3. Distributed Algorithms by Nancy Lynch, Morgan Kaufmann.
Mr. Sagar Pandya

Unit-4
 Distributed File Systems:
 File service architecture,
 Distributed File Systems Implementation,
 Naming System,
 Network File System (NFS),
 Flat and nested distributed transactions,
 Atomic commit protocols,
 Concurrency control in distributed transactions,
 Distributed deadlocks.
Mr. Sagar Pandya

INTRODUCTION
 What Does File System Mean?
 A file system is a process that manages how and where data on a storage
disk, typically a hard disk drive (HDD), is stored, accessed and managed.
 It is a logical disk component that manages a disk's internal operations as
it relates to a computer and is abstract to a human user.
 Regardless of type and usage, a disk contains a file system and
information about where disk data is stored and how it may be accessed
by a user or application.
 A file system typically manages operations, such as storage management,
file naming, directories/folders, metadata, access rules and privileges.
 Commonly used file systems include File Allocation Table 32 (FAT 32),
New Technology File System (NTFS) and Hierarchical File System
(HFS).
Mr. Sagar Pandya

INTRODUCTION
Mr. Sagar Pandya

INTRODUCTION
 A disk (e.g., Hard disk drive) has a file system, despite type and
usage.
 Also, it contains information about file size, file name, file location
fragment information, and where disk data is stored and also
describes how a user or application may access the data.
 The operations like metadata, file naming, storage management, and
directories/folders are all managed by the file system.
 On a storage device, files are stored in sectors in which data is stored
in groups of sectors called blocks.
 The size and location of the files are identified by the file system,
and it also helps to recognize which sectors are ready to be used.
Mr. Sagar Pandya

INTRODUCTION
 Sometimes the term "file system" is used in the reference of
partitions.
 For instance, saying, "on the hard drive, two files systems are
available," that does not have to mean the drive is divided between
two file systems, NTFS and FAT.
 But it means two separate partitions are there that use the same
physical disk.
Mr. Sagar Pandya

INTRODUCTION
 A Distributed File System (DFS) as the name suggests, is a file
system that is distributed on multiple file servers or multiple
locations.
 It allows programs to access or store isolated files as they do with the
local ones, allowing programmers to access files from any network
or computer.
 The main purpose of the Distributed File System (DFS) is to allows
users of physically distributed systems to share their data and
resources by using a Common File System.
 A collection of workstations and mainframes connected by a Local
Area Network (LAN) is a configuration on Distributed File System.
 A DFS is executed as a part of the operating system. In DFS, a
namespace is created and this process is transparent for the clients.
Mr. Sagar Pandya

INTRODUCTION
 DFS's primary goal is to enable users of physically distributed
systems to share resources and information through the Common
File System (CFS).
 It is a file system that runs as a part of the operating systems.
 Its configuration is a set of workstations and mainframes that a LAN
connects.
 The process of creating a namespace in DFS is transparent to the
clients.
 DFS has two components in its services, and these are as follows:
 1. Local Transparency
 2. Redundancy
Mr. Sagar Pandya

INTRODUCTION
 1. Location Transparency –
 Location Transparency achieves through the namespace component.
 2. Redundancy –
 Redundancy is done through a file replication component.
 In the case of failure and heavy load, these components together
improve data availability by allowing the sharing of data in different
locations to be logically grouped under one folder, which is known
as the “DFS root”.
 It is not necessary to use both the two components of DFS together,
it is possible to use the namespace component without using the file
replication component and it is perfectly possible to use the file
replication component without using the namespace component
between servers.
Mr. Sagar Pandya

INTRODUCTION
 History :
 The server component of the Distributed File System was initially
introduced as an add-on feature.
 It was added to Windows NT 4.0 Server and was known as “DFS
4.1”.
 Then later on it was included as a standard component for all editions
of Windows 2000 Server.
 Client-side support has been included in Windows NT 4.0 and also in
later on version of Windows.
 Linux kernels 2.6.14 and versions after it come with an SMB client
VFS known as “cifs” which supports DFS.
 Mac OS X 10.7 (lion) and onwards supports Mac OS X DFS.
Mr. Sagar Pandya

Features of DFS
 There are various features of the DFS. Some of them are as follows:
 Transparency
 There are mainly four types of transparency. These are as follows:
 1. Structure Transparency
 The client does not need to be aware of the number or location of file
servers and storage devices. In structure transparency, multiple file
servers must be given to adaptability, dependability, and
performance.
 2. Naming Transparency
 There should be no hint of the file's location in the file's name. When
the file is transferred form one node to other, the file name should not
be changed.
Mr. Sagar Pandya

Features of DFS
 3. Access Transparency
 Local and remote files must be accessible in the same method. The
file system must automatically locate the accessed file and deliver it
to the client.
 4. Replication Transparency
 When a file is copied across various nodes, the copies files and their
locations must be hidden from one node to the next.
 User mobility :
 It will automatically bring the user’s home directory to the node
where the user logs in.
 Simplicity and ease of use :
 The user interface of a file system should be simple and the number
of commands in the file should be small.
Mr. Sagar Pandya

Features of DFS
 Performance :
 Performance is based on the average amount of time needed to
convince the client requests.
 This time covers the CPU time + time taken to access secondary
storage + network access time.
 It is advisable that the performance of the Distributed File System be
similar to that of a centralized file system.
 Security :
 Heterogeneity in distributed systems is unavoidable as a result of
huge scale.
 Users of heterogeneous distributed systems have the option of using
multiple computer platforms for different purposes.
Mr. Sagar Pandya

Features of DFS
 High availability :
 A Distributed File System should be able to continue in case of any
partial failures like a link failure, a node failure, or a storage drive
crash.
 A high authentic and adaptable distributed file system should have
different and independent file servers for controlling different and
independent storage devices.
 Scalability :
 Since growing the network by adding new machines or joining two
networks together is routine, the distributed system will inevitably
grow over time.
 As a result, a good distributed file system should be built to scale
quickly as the number of nodes and users in the system grows.
Mr. Sagar Pandya

Features of DFS
 Service should not be substantially disrupted as the number of nodes
and users grows.
 High reliability :
 The likelihood of data loss should be minimized as much as feasible
in a suitable distributed file system.
 That is, because of the system’s unreliability, users should not feel
forced to make backup copies of their files.
 Rather, a file system should create backup copies of key files that can
be used if the originals are lost. Many file systems employ stable
storage as a high-reliability strategy.
 Heterogeneity :
 A distributed file system should be secure so that its users may trust
that their data will be kept private.
Mr. Sagar Pandya

Features of DFS
 To safeguard the information contained in the file system from
unwanted & unauthorized access, security mechanisms must be
implemented.
 Data integrity :
 Multiple users frequently share a file system.
 The integrity of data saved in a shared file must be guaranteed by the
file system.
 That is, concurrent access requests from many users who are
competing for access to the same file must be correctly synchronized
using a concurrency control method.
 Atomic transactions are a high-level concurrency management
mechanism for data integrity that is frequently offered to users by a
file system.
Mr. Sagar Pandya

Applications of DFS
 NFS –
 NFS stands for Network File System. It is a client-server architecture
that allows a computer user to view, store, and update files remotely.
 The protocol of NFS is one of the several distributed file system
standards for Network-Attached Storage (NAS).
 SMB –
 SMB stands for Server Message Block. It is a protocol for sharing a
file and was invented by IMB.
 The SMB protocol was created to allow computers to perform read
and write operations on files to a remote host over a Local Area
Network (LAN).
 The directories present in the remote host can be accessed via SMB
and are called as “shares”.
Mr. Sagar Pandya

Applications of DFS
 CIFS – CIFS stands for Common Internet File System.
 CIFS is an accent of SMB. That is, CIFS is an application of SIMB
protocol, designed by Microsoft.
 Hadoop – Hadoop is a group of open-source software services.
 It gives a software framework for distributed storage and operating
of big data using the MapReduce programming model.
 The core of Hadoop contains a storage part, known as Hadoop
Distributed File System (HDFS), and an operating part which is a
MapReduce programming model.
 NetWare – NetWare is an abandon computer network operating
system developed by Novell, Inc. It primarily used combined
multitasking to run different services on a personal computer, using
the IPX network protocol.
Mr. Sagar Pandya

Advantages of DFS
 Advantages
 There are various advantages of the distributed file system. Some of
the advantages are as follows:
 It allows the users to access and store the data.
 It helps to improve the access time, network efficiency, and
availability of files.
 It provides the transparency of data even if the server of disk files.
 It permits the data to be shared remotely.
 It helps to enhance the ability to change the amount of data and
exchange data.
Mr. Sagar Pandya

Disadvantages of DFS
 Disadvantages :
 In Distributed File System nodes and connections needs to be
secured therefore we can say that security is at stake.
 There is a possibility of lose of messages and data in the network
while movement from one node to another.
 Database connection in case of Distributed File System is
complicated.
 Also handling of the database is not easy in Distributed File System
as compared to a single user system.
 There are chances that overloading will take place if all nodes tries to
send data at once.
Mr. Sagar Pandya

Distributed File Systems
 A distributed file system provides similar abstraction to the users of a
distributed system and makes it convenient for them to use files in a
distributed environment.
 The design and implementation of a distributed file system, however,
is more complex than a conventional file system due to the fact that
the users and storage devices are physically dispersed.
 In addition to the advantages of permanent storage and sharing of
information provided by the file system of a single-processor system,
a distributed file system normally supports the following:
 1. Remote information sharing.
 A distributed file system allows a file to be transparently accessed by
processes of any node of the system irrespective of the file's location.
Mr. Sagar Pandya

 Therefore, a process on one node can create a file that can then be
accessed at a later time by some other process running on another
node.
 2. User mobility.
 In a distributed system, user mobility implies that a user should not
be forced to work on a specific node but should have the flexibility
to work on different nodes at different times.
 This property is desirable due to reasons such as coping with node
failures, suiting the nature of jobs of some users who need to work at
different places at different times, and enabling use of any of the
several nodes in those environments where workstations are
managed as a common pool.
Mr. Sagar Pandya

 A distributed file system normally allows a user to work on different
nodes at different times without the necessity of physically relocating
the secondary storage devices.
 3. Availability:-
 For better fault tolerance, files should be available for use even in the
event of temporary failure of one and more nodes of the system.
 To take care of this, a distributed file system normally keeps multiple
copies of a file on different nodes of the system.
 Each copy is called a replica of the file.
 In an ideal design, both the existence of multiple copies and their
locations are hidden from the clients.
Mr. Sagar Pandya

 4. Diskless workstations:-
 Disk drives are relatively expensive compared to the cost of most
other parts in a workstation.
 Furthermore, since a workstation is likely to be physically placed in
the immediate vicinity of a user, the noise and heat emitted from a
disk drive are annoying factors associated with a workstation.
 Therefore, a diskless workstation is more economical, is less noisy,
and generates less heat.
 A distributed file system, with its transparent remote file-accessing
capability, allows the use of diskless workstations in a system.
Mr. Sagar Pandya

Distributed File Systems - Services
 A distributed file system typically provides the following three types
of services. Each can be thought of as a component of a distributed
file system.
 1. Storage service: It deals with the allocation and management of
space on a secondary storage device that is used for storage of files
in the file system.
 It provides a logical view of the storage system by providing
operations for storing and retrieving data in them. Most systems use
magnetic disks as the secondary storage device for files.
 Therefore, the storage service is also known as disk service.
Furthermore, several systems allocate disk space in units of fixed-
size blocks, and hence, the storage service is also known as block
service in these systems.
Mr. Sagar Pandya

 2. True file service:
 It is concerned with the operations on individual files, such as
operations for accessing and modifying the data in files and for
creating and deleting files.
 To perform these primitive file operations correctly and efficiently,
typical design issues of a true file service component include file-
accessing mechanism, file-sharing semantics, file-caching
mechanism, file replication mechanism, concurrency control
mechanism, data consistency and multiple copy update protocol, and
access control mechanism.
 Note that the separation of the storage service from the true file
service makes it easy to combine different methods of storage and
different storage media in a single file system.
Mr. Sagar Pandya

 3. Name service:
 It provides a mapping between text names for files and references to
files, that is, file IDs.
 Text names are required because, as described in Chapter 10, file IDs
are awkward and difficult for human users to remember and use.
 Most file systems use directories to perform this mapping.
 Therefore, the name service is also known as a directory service.
 The directory service is responsible for performing directory-related
activities such as creation and deletion of directories, adding a new
file to a directory, deleting a file from a directory, changing the name
of a file, moving a file from one directory to another, and so on.
Mr. Sagar Pandya

Mr. Sagar Pandya

File Service Architecture
Mr. Sagar Pandya sagar.pandya@medicaps.ac.in
 An architecture that offers a clear separation of the main concerns in
providing access to files is obtained by structuring the file service as
three components – a flat file service, a directory service and a client
module.
 The flat file service and the directory service each export an interface
for use by client programs, and their RPC interfaces, taken together,
provide a comprehensive set of operations for access to files.
 The client module provides a single programming interface with
operations on files similar to those found in conventional file systems.
 The design is open in the sense that different client modules can be used
to implement different programming interfaces, simulating the file
operations of a variety of different operating systems and optimizing the
performance for different client and server hardware configurations.

File Service Architecture – Flat File Service
 The flat file service is concerned with implementing operations on the
contents of files.
 Unique file identifiers (UFIDs) are used to refer to files in all requests
for flat file service operations.
 The division of responsibilities between the file service and the
directory service is based upon the use of UFIDs.
 UFIDs are long sequences of bits chosen so that each file has a UFID
that is unique among all of the files in a distributed system.
 When the flat file service receives a request to create a file, it generates
a new UFID for it and returns the UFID to the requester.

File Service Architecture – Directory service
 Directory service:
 The directory service provides a mapping between text names for files
and their UFIDs.
 Clients may obtain the UFID of a file by quoting its text name to the
directory service.
 The directory service provides the functions needed to generate
directories, to add new file names to directories and to obtain UFIDs
from directories.
 It is a client of the flat file service; its directory files are stored in files
of the flat file service.
 When a hierarchic file-naming scheme is adopted, as in UNIX,
directories hold references to other directories.

File Service Architecture – Client module
 Client module
 A client module runs in each client computer, integrating and extending
the operations of the flat file service and the directory service under a
single application programming interface that is available to user-level
programs in client computers.
 For example, in UNIX hosts, a client module would be provided that
emulates the full set of UNIX file operations, interpreting UNIX multi-
part file names by iterative requests to the directory service.
 The client module also holds information about the network locations of
the flat file server and directory server processes.
 Finally, the client module can play an important role in achieving
satisfactory performance through the implementation of a cache of
recently used file blocks at the client.

 Flat file service interface:
 Figure 12.6 contains a definition of the interface to a flat file service.
 This is the RPC interface used by client modules.
 It is not normally used directly by user-level programs.
 A FileId is invalid if the file that it refers to is not present in the server
processing the request or if its access permissions are inappropriate for
the operation requested.
 All of the procedures in the interface except Create throw exceptions if
the FileId argument contains an invalid UFID or the user doesn’t have
sufficient access rights.
 These exceptions are omitted from the definition for clarity.
 The most important operations are those for reading and writing.

 Both the Read and the Write operation require a parameter i
specifying a position in the file.
 The Read operation copies the sequence of n data items beginning at
item i from the specified file into Data, which is then returned to the
client.
 The Write operation copies the sequence of data items in Data into
the specified file beginning at item i, replacing the previous contents
of the file at the corresponding position and extending the file if
necessary.
 Create creates a new, empty file and returns the UFID that is
generated. Delete removes the specified file.
 GetAttributes and SetAttributes enable clients to access the attribute
record.

 GetAttributes is normally available to any client that is allowed to
read the file.
 Access to the SetAttributes operation would normally be restricted to
the directory service that provides access to the file.
 The values of the length and timestamp portions of the attribute
record are not affected by SetAttributes; they are maintained
separately by the flat file service itself.
 Comparison with UNIX:
 In comparison with the UNIX interface, our flat file service has no
open and close operations – files can be accessed immediately by
quoting the appropriate UFID.

 The Read and Write requests in our interface include a parameter
specifying a starting point within the file for each transfer, whereas
the equivalent UNIX operations do not.
 In UNIX, each read or write operation starts at the current position of
the read-write pointer, and the read-write pointer is advanced by the
number of bytes transferred after each read or write.
 A seek operation is provided to enable the read-write pointer to be
explicitly repositioned.
 The interface to our flat file service differs from the UNIX file
system interface mainly for reasons of fault tolerance:

 Repeatable operations: With the exception of Create, the operations
are idempotent, allowing the use of at-least-once RPC semantics –
clients may repeat calls to which they receive no reply. Repeated
execution of Create produces a different new file for each call.
 Stateless servers: The interface is suitable for implementation by
stateless servers. Stateless servers can be restarted after a failure and
resume operation without any need for clients or the server to restore
any state.
 The UNIX file operations are neither idempotent nor consistent with
the requirement for a stateless implementation.
 A read-write pointer is generated by the UNIX file system whenever
a file is opened, and it is retained, together with the results of access-
control checks, until the file is closed.

 Directory service interface:
 Figure 12.7 contains a definition of the RPC interface to a directory
service.
 The primary purpose of the directory service is to provide a service
for translating text names to UFIDs. In order to do so, it maintains
directory files containing the mappings between text names for files
and UFIDs.
 Each directory is stored as a conventional file with a UFID, so the
directory service is a client of the file service.
 For each operation, a UFID for the file containing the directory is
required (in the Dir parameter).
 The Lookup operation in the basic directory service performs a single
Name o UFID translation.

 There are two operations for altering directories: AddName and
UnName.
 AddName adds an entry to a directory and increments the reference
count field in the file’s attribute record.
 UnName removes an entry from a directory and decrements the
reference count.
 If this causes the reference count to reach zero, the file is removed.
 GetNames is provided to enable clients to examine the contents of
directories and to implement pattern-matching operations on file
names such as those found in the UNIX shell.
 It returns all or a subset of the names stored in a given directory.
 The names are selected by pattern matching against a regular
expression supplied by the client.

FILE-ACCESSING MODELS
 The manner in which a client's request to access a file is serviced
depends on the file accessing model used by the file system.
 The file-accessing model of a distributed file system mainly depends
on two factors-the method used for accessing remote files and the
unit of data access.
 Accessing Remote Files:
 A distributed file system may use one of the following models to
service a client's file access request when the accessed file is a
remote file:
 1. Remote service model:
 In this model, the processing of the client's request is performed at
the server's node.

 That is, the client's request for file access is delivered to the server,
the server machine performs the access request, and finally the result
is forwarded back to the client.
 The access requests from the client and the server replies for the
client are transferred across the network as messages.
 Notice that the data packing and communication overheads per
message can be significant.
 Therefore, if the remote service model is used, the file server
interface and the communication protocols must be designed
carefully to minimize the overhead of generating messages as well as
the number of messages that must be exchanged in order to satisfy a
particular request.

 2. Data-caching model:
 In the remote service model, every remote file access request results
in network traffic.
 The data-caching model attempts to reduce the amount of network
traffic by taking advantage of the locality feature found in file
accesses.
 In this model, if the data needed to satisfy the client's access request
is not present locally, it is copied from the server's node to the client's
node and is cached there.
 The client's request is processed on the client's node itself by using
the cached data.
 Recently accessed data are retained in the cache for some time so that
repeated accesses to the same data can be handled locally.

 A replacement policy, such as the least recently used (LRU), is used
to keep the cache size bounded.
 As compared to the remote access model, this model greatly reduces
network traffic.
 However, in this model, there is a possibility that data of a particular
file may simultaneously be available in different caches.
 Therefore, a write operation often incurs substantial overhead
because, in addition to modifying the locally cached copy of the data,
the changes must also be made in the original file at the server node
and in any other caches having the data, depending on the relevant
sharing semantics.
 The problem of keeping the cached data consistent with the original
file content is referred to as the cache consistency problem.

 As compared to the remote service model, the data-caching model
offers the possibility of increased performance and greater system
scalability because it reduces network traffic, contention for the
network, and contention for the file servers.
 Therefore, almost all existing distributed file systems implement
some form of caching. In fact, many implementations can be thought
of as a hybrid of the remote service and the data-caching models.
 For example, LOCUS [Popek and Walker 1985] and the Network
File System (NFS) [Sandberg et al. 1985] use the remote service
model but add caching for better performance.
 On the other hand, Sprite [Nelson et al. 1988] uses the data-caching
model but employs the remote service method under certain
circumstances.

 Unit of Data Transfer: In file systems that use the data-caching
model, an important design issue is to decide the unit of data transfer.
 Unit of data transfer refers to the fraction (or its multiples) of a file
data that is transferred to and from clients as a result of a single read
or write operation.
 The four commonly used data transfer models based on this factor
are as follows:
 1. File-level transfer model: In this model, when an operation
requires file data to be transferred across the network in either
direction between a client and a server, the whole file is moved.
 First, transmitting an entire file in response to a single request is
more efficient than transmitting it page by page in response to several
requests because the network protocol overhead is required only
once.

 Second, it has better scalability because it requires fewer accesses to
file servers, resulting in reduced server load and network traffic.
 Third, disk access routines on the servers can be better optimized if it
is known that requests are always for entire files rather than for
random disk blocks.
 Fourth, once an entire file is cached at a client's site, it becomes
immune to server and network failures.
 Finally, it also simplifies the task of supporting heterogeneous
workstations.
 This is because it is easier to transform an entire file at one time from
the form compatible with the file system of server workstation to the
form compatible with the file system of the client workstation or vice
versa.

 On the other hand, the main drawback of this model is that it requires
sufficient storage space on the client's node for storing all the
required files in their entirety.
 Therefore, this approach fails to work with very large files, especially
when the client runs on a diskless workstation.
 Even when the client's workstation is not diskless, files that are larger
than the local disk capacity cannot be accessed at all.
 Furthermore, if only a small fraction of a file is needed, moving the
whole file is wasteful.
 Amoeba [Mullender and Tanenbaum 1984], CFS [Gifford et al.
1988], and the Andrew File System (AFS-2) [Satyanarayanan 1990b]
arc a few examples of distributed systems that use the file-level
transfer model.

 2. Block-level transfer model:
 In this model, file data transfers across the network between a client
and a server take place in units of file blocks.
 A file block is a contiguous portion of a file and is usually fixed in
length.
 For file systems in which block size is equal to virtual memory page
size, this model is also called a page-level transfer model.
 The advantage of this model is that it does not require client nodes to
have large storage space.
 It also eliminates the need to copy an entire file when only a small
portion of the file data is needed.
 Therefore, this model can be used in systems having diskless
workstations.

 It provides large virtual memory for client nodes that do not have
their own secondary storage devices.
 However, when an entire file is to be accessed, multiple server
requests are needed in this model, resulting in more network traffic
and more network protocol overhead.
 Therefore, this model has poor performance as compared to the file
level transfer model when the access requests are such that most files
have to be transferred in their entirety.
 The Apollo Domain File System [Leach et al. 1983], Sun
Microsystem's NFS [Sandberg 1987], LOCUS [Popek and Walker
1985], and Sprite [Nelson et al, 1988] are a few examples of
distributed systems that use the block-level transfer model.

 3. Byte-level transfer model:
and a server take place in units of bytes.
 This model provides maximum flexibility because it allows storage
and retrieval of an arbitrary sequential subrange of a file, specified by
an offset within a file, and a length.
 The main drawback of this model is the difficulty in cache
management due to the variable-length data for different access
requests.
 The Cambridge File Server [Dion 1980, Mitchell and Dion 1982,
Needham and Herbert 1982] uses this model.

 4. Record-level transfer model:
 The three file data transfer models described above are commonly
used with unstructured file models.
 The record-level transfer model is suitable for use with those file
models in which file contents are structured in the form of records.
and a server take place in units of records.
 The Research Storage System (RSS) [Gray 1978, Gray et al. 1981],
which supports complex access methods to structured and indexed
files, uses the record-level transfer model.

FILE-CACHING SCHEMES
 File caching has been implemented in several file systems for
centralized time-sharing systems to improve file I/O performance
(e.g., UNIX [McKusick et a1. 1985]).
 The idea in file caching in these systems is to retain recently accessed
file data in main memory, so that repeated accesses to the same
information can be handled without additional disk transfers.
 Because of locality in file access patterns, file caching reduces disk
transfers substantially, resulting in better overall performance of the
file system.
 The property of locality in file access patterns can as well be
exploited in distributed systems by designing a suitable file-caching
scheme.

 In addition to better performance, a file-caching scheme for a
distributed file system may also contribute to its scalability and
reliability because it is possible to cache remotely located data on a
client node.
 Therefore, every distributed file system in serious use today uses
some form of file caching. Even AT&T's Remote File System (RFS)
[Rifkin et a1. ]986], which initially avoided caching to emulate
UNIX semantics, now uses it.
 In addition to these issues, a file-caching scheme for a distributed file
system should also address the following key decisions:
 1. Cache location
 2. Modification propagation
 3. Cache validation

 1. Cache location
 Cache location refers to the place where the cached data is stored.
Assuming that the original location of a file is on its server's disk,
there are three possible cache locations in a distributed file system
 1. Server's main memory:
 When no caching scheme is used, before a remote client can access a
file, the file must first be transferred from the server's disk to the
server's main memory and then across the network from the server's
main memory to the client's main memory.
 Therefore, the total cost involved is one disk access and one network
access. A cache located in the server's main memory eliminates the
disk access cost on a cache hit, resulting in a considerable
performance gain as compared to no caching.

 The decision to locate the cache in the server's main memory may be
taken due to one or more of the following reasons.
 It is easy to implement and is totally transparent to the clients.
 It is easy to always keep the original file and cached data consistent
since both reside on the same node.
 Furthermore, since a single server manages both the cached data and
the file, multiple accesses from different clients can be easily
synchronized to support UNIX-like file-sharing semantics.
 However, having the cache in the server's main memory involves a
network access for each file access operation by a remote client and
processing of the access request by the server.
 Therefore, it does not eliminate the network access cost and does not
contribute to the scalability and reliability of the distributed file system.

 2. Client's disk:
 The second option is to have the cache in a client's disk.
 A cache located in a client's disk eliminates network access cost but
requires disk access cost on a cache hit.
 A cache on a disk has several advantages.
 The first is reliability. Modifications to cached data are lost in a crash if
the cache is kept in volatile memory.
 Moreover, if the cached data is kept on the client's disk, the data is still
there during recovery and there is no need to fetch it again from the
server's node. The second advantage is large storage capacity.
 As compared to a main-memory cache, a disk cache has plenty of
storage space. Therefore, more data can be cached, resulting in a higher
hit ratio.

 Several distributed file systems use the file-level data transfer model
in which a file is always cached in its entirety. In these systems, if a
file is too large to fit in a main-memory cache, the advantages of file
caching cannot be availed for it.
 Therefore, disk cache is particularly useful for those systems that use
the file-level transfer model because it allows the caching of most
large files unless the file to be cached is larger than the available disk
space.
 The third advantage is disconnected operation. A system may use a
client's disk caching and the file-level transfer model to support
disconnected operation.
 A client's disk cache also contributes to scalability and reliability
because on a cache hit the access request can be serviced locally
without the need to contact the server.

 3. Client's main memory:
 The third alternative is to have the cache in a client's main memory.
 A cache located in a client's main memory eliminates both network
access cost and disk access cost.
 Therefore, it provides maximum performance gain on a cache hit.
 It also permits workstations to be diskless. Like a client's disk cache,
a client's main memory cache also contributes to scalability and
reliability because on a cache hit the access request can be serviced
locally without the need to contact the server.
 However, a client's main-memory cache is not preferable to a client's
disk cache when large cache size and increased reliability of cached
data are desired.

FILE REPLICATION
 High availability is a desirable feature of a good distributed file
system and file replication is the primary mechanism for improving
file availability.
 A replicated file is a file that has multiple copies, with each copy
located on a separate file server.
 Each copy of the set of copies that comprises a replicated file is
referred to as a replica of the replicated file.
 Difference between Replication and Caching
 Replication is often confused with caching, probably because they
both deal with multiple copies of a data.
 However, the two concepts have the following basic differences:
 1. A replica is associated with a server, whereas a cached copy is
normally associated with a client.

FILE REPLICATION
 2. The existence of a cached copy is primarily dependent on the
locality in file access patterns, whereas the existence of a replica
normally depends on availability and performance requirements.
 3. As compared to a cached copy, a replica is more persistent, widely
known, secure, available, complete, and accurate.
 4. A cached copy is contingent upon a replica. Only by periodic
revalidation with respect to a replica can a cached copy be useful.
 Advantages of Replication:
 The replication of data in a distributed system offers the following
potential benefits:
 1. Increased availability: One of the most important advantages of
replication is that it masks and tolerates failures in the network
gracefully.

FILE REPLICATION
 In particular, the system remains operational and available to the
users despite failures.
 By replicating critical data on servers with independent failure
modes, the probability that one copy of the data will be accessible
increases. Therefore, alternate copies of a replicated data can be used
when the primary copy is unavailable.
 2. Increased reliability: Many applications require extremely high
reliability of their data stored in files.
 Replication is very advantageous for such applications because it
allows the existence of multiple copies of their files.
 Due to the presence of redundant information in the system, recovery
from catastrophic failures (such as permanent loss of data of a
storage device) becomes possible.

FILE REPLICATION
 3. Improved response time:
 Replication also helps in improving response time because it enables
data to be accessed either locally or from a node to which access time
is lower than the primary copy access time.
 The access time differential may arise either because of network
topology or because of uneven loading of nodes.
 4. Reduced network traffic: If a file's replica is available with a file
server that resides on a client's node, the client's access requests can
be serviced locally, resulting in reduced network traffic.
 5. Improved system throughput:
 Replication also enables several clients' requests for access to the
same file to be serviced in parallel by different servers, resulting in
improved system throughput.

FILE REPLICATION
 6. Better scalability: As the number of users of a shared file grows,
having all access requests for the file serviced by a single file server
can result in poor performance due to overloading of the file server.
 By replicating the file on multiple servers, the same requests can now
be serviced more efficiently by multiple servers due to workload
distribution. This results in better scalability.
 7. Autonomous operation: In a distributed system that provides file
replication as a service to their clients, all files required by a client
for operation during a limited time period may be replicated on the
file server residing at the client's node.
 This will facilitate temporary autonomous operation of client
machines. A distributed system having this feature can support
detachable, portable machines,

FILE REPLICATION
 Replication Transparency:
 Transparency is an important issue in file replication.
 A replicated file service must function exactly like a non replicated
file service but exhibit improved performance and reliability.
 That is, replication of files should be designed to be transparent to the
users so that multiple copies of a replicated file appear as a single
logical file to its users.
 For this, the read, write, and other file operations should have the
same client interface whether they apply to a non replicated file or to
a replicated file.
 Two important issues related to replication transparency are naming
of replicas and replication control.

FILE REPLICATION
 Naming of Replicas: In systems that support object replication. a
basic question is whether different replicas of an object should be
assigned the same identifier or different identifiers.
 Obviously, the replication transparency requirement calls for the
assignment of a single identifier to all replicas of an object.
 Assignment of a single identifier to all replicas of an object seems
reasonable for immutable objects because a kernel can easily support
this type of object.
 Any copy found by the kernel can be used, because all copies are
immutable and identical; there is only one logical object with a given
identifier.
 However, in mutable objects, different copies of a replicated object
may not be the same (consistent) at a particular instance of time.

FILE REPLICATION
 In this case, if the same identifier is used for all replicas of the object,
the kernel cannot decide which replica is the most up-to-date one.
 Therefore, the consistency control and management of the various
replicas of a mutable object should be performed outside the kernel.
 Hence it is the responsibility of the naming system to map a user-
supplied identifier into the appropriate replica of a mutable object.
 Furthermore, if all replicas are consistent, the mapping must provide
the locations of all replicas and a mechanism to identify the relative
distances of the replicas from the user's node.

FILE REPLICATION
 Replication Control:
 Another transparency issue is providing replication control.
 Replication control includes determining the number and locations of
replicas of a replicated file.
 That is, do the users play any role in determining how many copies
of a replicated file should be created and on which server should each
copy be placed?
 In a replication transparent system, the replication control is handled
entirely automatically, in a user-transparent manner.
 However, under certain circumstances, it is desirable to expose these
details to users and to provide them with the flexibility to control the
replication process.

FILE REPLICATION
 Depending on whether replication control is user transparent or not,
the replication process is of two types:
 1. Explicit replication:
 In this type, users are given the flexibility to control the entire
replication process.
 That is, when a process creates a file, it specifies the server on which
the file should be placed.
 Then, if desired, additional copies of the file can be created on other
servers on explicit request by the users.
 Users also have the flexibility to delete one or more replicas of a
replicated file.

FILE REPLICATION
 2. Implicit/lazy replication:
 In this type, the entire replication process is automatically controlled
by the system without users' knowledge.
 That is, when a process creates a file, it does not provide any
information about its location.
 The system automatically selects one server for the placement of the
file. Later, the system automatically creates replicas of the file on
other servers, based on some replication policy used by the system.
 The system must be intelligent enough to create and allow the
existence of only as many replicas as are necessary and should
automatically delete any extra copies when they are no longer
needed. Lazy replication is normally performed in the background
when the server has some free time.

FAULT TOLERANCE
 Fault tolerance is an important issue in the design of a distributed file
system.
 Various types of faults could harm the integrity of the data stored by
such a system.
 For instance, a processor loses the contents of its main memory in the
event of a crash.
 Such a failure could result in logically complete but physically
incomplete file operations, making the data that are stored by the file
system inconsistent.
 Similarly, during a request processing, the server or client machine
may crash, resulting in the loss of state information of the file being
accessed.
 This may have an uncertain effect on the integrity of file data.

FAULT TOLERANCE
 Also, other adverse environmental phenomena such as transient
faults (caused by electromagnetic fluctuations) or decay of disk
storage devices may result in the loss or corruption of data stored by
a file system.
 A portion of a disk storage device is said to be "decayed" if the data
on that portion of the device are irretrievable.
 1. Availability:
 Availability of a file refers to the fraction of time for which the file is
available for use.
 Note that the availability property depends on the location of the file
and the locations of its clients (users).

FAULT TOLERANCE
 For example, if a network is partitioned due to a communication link
failure, a file may be available to the clients of some nodes, but at the
same time, it may not be available to the clients of other nodes.
 Replication is a primary mechanism for improving the availability of
a file.
 2. Robustness:
 Robustness of a file refers to its power to survive crashes of the
storage device and decays of the storage medium on which it is
stored.
 Storage devices that are implemented by using redundancy
techniques, such as a stable storage device, are often used to store
robust files.

FAULT TOLERANCE
 Note that a robust file may not be available until the faulty
component has been recovered.
 Furthermore, unlike availability, robustness is independent of either
the location of the file or the location of its clients.
 3. Recoverability:
 Recoverability of a file refers to its ability to be rolled back to an
earlier, consistent state when an operation on the file fails or is
aborted by the client.
 Notice that a robust file is not necessarily recoverable and vice versa.
 Atomic update techniques such as a transaction mechanism are used
to implement recoverable files.

Network File System
 NFS is an abbreviation of the Network File System. It is a protocol of
a distributed file system.
 This protocol was developed by the Sun Microsystems in the year of
1984.
 It is an architecture of the client/server, which contains a client
program, server program, and a protocol that helps for
communication between the client and server.
 It is that protocol which allows the users to access the data and files
remotely over the network.
 Any user can easily implement the NFS protocol because it is an
open standard.
 Any user can manipulate files as same as if they were on like other
protocols.

Network File System
 This protocol is mainly implemented on those computing
environments where the centralized management of resources and
data is critical.
 It uses the Transmission Control Protocol (TCP) and User Datagram
Protocol (UDP) for accessing and delivering the data and files.
 Network File System is a protocol that works on all the networks of
IP-based.
 It is implemented in that client/server application in which the server
of NFS manages the authorization, authentication, and clients.
 This protocol is used with Apple Mac OS, Unix, and Unix-like
operating systems such as Solaris, Linux, FreeBSD, AIX.

Benefits of Using NFS
 Multiple clients can use the same files, which allows everyone on the
network to use the same data, accessing it on remote hosts as if it
were acceding local files.
 Computers share applications, which eliminates the needs for local
disk space and reduces storage costs.
 All users can read the same files, so data can remain up-to-date, and
it’s consistent and reliable. Mounting the file system is transparent to
all users.
 Support for heterogeneous environments allows you to run mixed
technology from multiple vendors and use interoperable components.
 System admin overhead is reduced due to centralization of data.
 Fewer removable disks and drives laying around provides a reduction
of security concerns—which is always good!

How Does Network File System Work?
 Fundamentally, the NFS client-server protocol begins with a “mount”
command, which specifies client and server software options or
attributes.
 NFSv4 is a stateful protocol, with over 30 unique options that can be
specified on the mount command ranging from read/write block size,
and protocol used.
 Security protocols validate client access to data files as well as data
security options, etc.
 Some of the more interesting NFS protocol software options include
caching options, shared file locking characteristics, and security
support.
 File locking and caching interact together, and both must be properly
specified for shared file access to work.

How Does Network File System Work?
 If file (read or write) data only resides in a host cache and some other
host tries to access the same file, the data it reads could be wrong,
unless both (or rather) all clients of the NFS storage server use the
SAME locking options and caching options for the mounted file
system.
 File locking was designed to support shared file access.
 That is when a file is accessed by more than one application or
(compute) thread.
 Shared file access could be occurring within a single host (with or
without multi-core/multi-thread) or across different hosts accessing
the same file over NFS.

Disadvantages of Network File System
 There are many challenges with the current NFS Internet Standard
that may or may not be addressed in the future;
 for example, some reviews of NFSv4 and NFSv4.1 suggest that these
versions have limited bandwidth and scalability (improved with
NFSv4.2) and that NFS slows down during heavy network traffic.
Here are some others:
 Security— First and foremost is a security concern, given that NFS
is based on RPCs which are inherently insecure and should only be
used on a trusted network behind a firewall. Otherwise, NFS will be
vulnerable to internet threats.
 Protocol chattiness— The NFS client-server protocol requires a lot
of request activity to be set up to transfer data.

 The NFS protocol requires many small interactions or steps to read
and write data, which equates to a ton of overhead for someone
actively interacting with today’s AI/ML/DL workloads that consume
a tremendous number of small files.
 File sharing is highly complex— Configuring and setting up proper
shared file access via file locking and caching is a daunting task at
best.
 On the one hand, it adds a lot of the protocol overhead, leading to the
chattiness mentioned above.
 On the other hand, it still leaves a lot to be desired, inasmuch any
each host’s mount command for the same file system can easily go
awry.

 Parallel file access— NFS was designed as a way to sequentially
access a shared network file, but these days applications are dealing
with larger files and non-sequential or parallel file access is required.
This was added to NFSv4, but not a lot of clients support it yet.
 Block size limitations— The current NFS protocol standard allows
for a maximum of 1MB of data to be transferred during one read or
write request. In 1984, 1MB was a lot of data, but that’s no longer the
case. There are classes of applications that should be transferring
GBs not MBs of data.

Naming System
 A distributed system supports several types of objects such as
processes, files, I/O devices, mail boxes, and nodes.
 The naming facility of a distributed operating system enables users
and programs to assign character-string names to objects and
subsequently use these names to refer to those objects.
 The locating facility, which is an integral part of the naming facility,
maps an object's name to the object's location in a distributed system.
 The naming and locating facilities jointly form a naming system that
provides the users with an abstraction of an object that hides the
details of how and where an object is actually located in the network.
 It provides a further level of abstraction when dealing with object
replicas. Given an object name, it returns a set of the locations of the
object's replicas.

Naming System
 The naming system plays a very important role in achieving the goal
of location transparency in a distributed system.
 In addition to facilitating transparent migration and replication of
objects, the naming system also facilitates object sharing.
 If various computations want to act upon the same object, they are
enabled to do so by each containing a name for the object.
 Although the names contained in each computation may not
necessarily be the same, they are mapped to the same object in this
case.
 A name in a distributed system is a string of bits or characters that is
used to refer to an entity.
 An entity in a distributed system can be practically anything.
 Typical examples include resources such as hosts, printers, disks, and
files.

Naming System
 Other well-known examples of entities that are often explicitly
named are processes, users, mailboxes, newsgroups, Web pages,
graphical windows, messages, network connections, and so on.
 For example, a resource such as a printer offers an interface
containing operations for printing a document, requesting the status
of a print job, and the like.
 Furthermore, an entity such as a network connection may provide
operations for sending and receiving data, setting quality-of-service
parameters, requesting the status, and so forth.
 To operate on an entity, it is necessary to access it, for which we need
an access point.
 An access point is yet another, but special, kind of entity in a
distributed system. The name of an access point is called an address.

Naming System
 DESIRABLE FEATURES OF A GOOD NAMING SYSTEM
 A good naming system for a distributed system should have the features
described below.
 1. Location transparency:
 Location transparency means that the name of an object should not reveal
any hint as to the physical location of the object.
 That is, an object's name should be independent of the physical connectivity
or topology of the system, or the current location of the object.
 2. Location independency:
 For performance, reliability, availability, and security reasons, distributed
systems provide the facility of object migration that allows the movement
and relocation of objects dynamically among the various nodes of a system

Naming System
 Location independency means that the name of an object need not be
changed when the object's location changes.
 Furthermore, a user should be able to access an object by its same
name irrespective of the node from where he or she accesses it.
 Therefore, the requirement of location independency calls for a
global naming facility with the following two features:
 An object at any node can be accessed without the knowledge of its
physical location (location independency of request-receiving
objects).
 An object at any node can issue an access request without the
knowledge of its own physical location (location independency of
request-issuing objects). This property is also known as user
mobility.

Naming System
 3. Scalability:
 Distributed systems vary in size ranging from one with a few nodes
to one with many nodes.
 Moreover, distributed systems are normally open systems, and their
size changes dynamically.
 Therefore, it is impossible to have an a priori idea about how large
the set of names to be dealt with is liable to get.
 Hence a naming system must be capable of adapting to the
dynamically changing scale of a distributed system that normally
leads to a change in the size of the name space.
 That is, a change in the system scale should not require any change
in the naming or locating mechanisms.

Naming System
 4. Uniform naming convention:
 In many existing systems, different ways of naming objects, called
naming conventions, are used for naming different types of objects.
 For example, file names typically differ from user names and process
names.
 Instead of using such nonuniform naming conventions, a good
naming system should use the same naming convention for all types
of objects in the system.
 5. Multiple user-defined names for the same object:
 For a shared object, it is desirable that different users of the object
can use their own convenient names for accessing it

Naming System
 Therefore, a naming system must provide the flexibility to assign
multiple user-defined names to the same object.
 In this case, it should be possible for a user to change or delete his or
her name for the object without affecting those of other users.
 6. Group naming:
 A naming system should allow many different objects to be
identified by the same name. Such a facility is useful to support
broadcast facility or to group objects for conferencing or other
applications.
 7. Meaningful names: A name can be simply any character string
identifying some object. However, for users, meaningful names are
preferred to lower level identifiers such as memory pointers, disk
block numbers, or network addresses.

Naming System
 This is because meaningful names typically indicate something about
the contents or function of their referents, are easily transmitted
between users, and are easy to remember and use.
 Therefore, a good naming system should support at least two levels
of object identifiers, one convenient for human users and one
convenient for machines.
 8. Performance:
 The most important performance measurement of a naming system is
the amount of time needed to map an object's name to its attributes,
such as its location.
 In a distributed environment, this performance is dominated by the
number of messages exchanged during the name-mapping operation.

Naming System
 Therefore, a naming system should be efficient in the sense that the
number of messages exchanged in a name-mapping operation should
be as small as possible.
 9. Fault tolerance:
 A naming system should be capable of tolerating, to some extent,
faults that occur due to the failure of a node or a communication link
in a distributed system network.
 That is, the naming system should continue functioning, perhaps in a
degraded form, in the event of these failures.
 The degradation can be in performance, functionality, or both but
should be proportional, in some sense, to the failures causing it.

Naming System
 11. Locating the nearest replica:
 When a naming system supports the use of multiple copies of the
same object, it is important that the object-locating mechanism of the
naming system should always supply the location of the nearest
replica of the desired object.
 This is because the efficiency of the object accessing operation will
be affected if the object-locating mechanism does not take this point
into consideration.

Naming System
 This is illustrated by the example given in Figure , where the desired
object is replicated at nodes N2 , N3 , and N4 and the object-locating
mechanism is such that it maps to the replica at node N4 instead of
the nearest replica at node N2 . Obviously this is undesirable.
 12. Locating all replicas:
 In addition to locating the nearest replica of an object, it is also
important from a reliability point of view that all replicas of the
desired object be located by the object-locating mechanism.
 A need for this property is illustrated in Figure 10, where the nearest
replica at node N5 is currently inaccessible due to a communication
link failure in the network. In this case, another replica of the object
at a farther node N4 can be used.

Naming System

FUNDAMENTAL TERMINOLOGIES AND
CONCEPTS
 The naming system is one of the most important components of a
distributed operating system because it enables other services and
objects to be identified and accessed in a uniform manner.
 Name: A name is a string composed of a set of symbols chosen from
a finite alphabet.
 For example, ALEX,#173#4879#5965, node-1!node-2!node-3!alex,
/a/b/c, 25A2368DM197, etc. care all valid names composed of
symbols from the ASCII character set.
 A name is also called an identifier because it is used to denote or
identify an object.
 A name may also be thought of as a logical object that identifies a
physical object to which it is bound from among a collection of
physical objects

CONCEPTS
 Human-Oriented and System-Oriented Names:
 Names are used to designate or refer to objects at all levels of system
architecture.
 They have various purposes, forms, and properties depending on the
levels at which they are defined.
 However, an informal distinction can be made between two basic
classes of names widely used in operating systems-human-oriented
names and system-oriented names.
 A human-oriented name is generally a character string that is
meaningful to its users.
 For example, user/alex/project-I/file-1 is a human-oriented name.
Human-oriented names are defined by their users.

CONCEPTS
 For a shared object, different users of the object must have the
flexibility to define their own human-oriented names for the object
for accessing it.
 Flexibility must also be provided so that a user can change or delete
his or her own name for the object without affecting those of other
users.
 For transparency, human oriented names should be independent of
the physical location or the structure of objects they designate.
 Human-oriented names are also known as high-level names because
they can be easily remembered by their users.
 Human-oriented names are not unique for an object and are normally
variable in length not only for different objects but also for different
names for the same object.

CONCEPTS
 Hence, they cannot be easily manipulated, stored, and used by the
machines for identification purpose. Moreover, it must be possible at some
level to uniquely identify every object in the entire system.
 Therefore, in addition to human-oriented names, which are useful for
users, system-oriented names are needed to be used efficiently by the
system.
 These names generally are bit patterns of fixed size that can be easily
manipulated and stored by machines.
 They are automatically generated by the system. They should be generated
in a distributed manner to avoid the problems of efficiency and reliability
of a centralized unique identifier generator.
 They are basically meant for use by the system but may also be used by
the users. They are also known as unique identifiers and low-level names.

CONCEPTS
 In this naming model, a human-oriented name is first mapped
(translated) to a system-oriented name that is then mapped to the
physical locations of the corresponding object's replicas.

Naming System
 Name Space:
 A naming system employs one or more naming conventions for name
assignment to objects.
 For example, a naming system may use one naming convention for
assigning human-oriented names to objects and another naming
convention for assigning system oriented names to objects.
 The syntactic representation of a name as well as its semantic
interpretation depends on the naming convention used for that name.
 The set of names complying with a given naming convention is said
to form a name space.

Naming System
 Flat Name Space:
 The simplest name space is a flat name space where names are
character strings exhibiting no structure.
 Names defined in a flat name space are called primitive or flat
names.
 Since flat names do not have any structure, it is difficult to assign
unambiguous meaningful names to a large set of objects.
 Therefore, flat names are suitable for use either for small name
spaces having names for only a few objects or for system-oriented
names that need not be meaningful to the users.

Naming System
 Partitioned Name Space:
 When there is a need to assign unambiguous meaningful names to a
large set of objects, a naming convention that partitions the name
space into disjoint classes is normally used.
 When partitioning is done syntactically, which is generally the case,
the name structure reflects physical or organizational associations.
 Each partition of a partitioned name space is called a domain of the
name space.
 Each domain of a partitioned name space may be viewed as a flat
name space by itself, and the names defined in a domain must be
unique within that domain.
 However, two different domains may have a common name defined
within them.

Naming System
 A name defined in a domain is called a simple name. In a partitioned
name space, all objects cannot be uniquely identified by simple
names, and hence compound names are used for the purpose of
unique identification.
 A compound name is composed of one or more simple names that
are separated by a special delimiter character such as I, $, @, %, and
so on.
 For example, /a/b/c is a compound name consisting of three simple
names a, b, and c.
 A commonly used type of partitioned name space is the hierarchical
name space, in which the name space is partitioned into multiple
levels and is structured as an inverted tree.

Naming System
 Each node of the name space tree corresponds to a domain of the
name space. In this type of name space, the number of levels may be
either fixed or arbitrary.
 Names defined in a hierarchical name space are called hierarchical
names. Hierarchical names have been used in file systems for many
years and have recently been adopted for naming other objects as
well in distributed systems.
 Several examples of hierarchical name spaces are also found in our
day-to-day life. For instance, telephone numbers fully expanded to
include country and area codes form a four-level hierarchical name
space and network addresses in computer networks form a three-
level hierarchical name space where the three levels are for network
number, node number, and socket number.

Naming System - Name Server
 Name spaces are managed by name servers.
 A name server is a process that maintains information about named
objects and provides facilities that enable users to access that
information.
 In practice, several name servers are normally used for managing the
name space of object names in a distributed system.
 Each name server normally has information about only a small
subset of the set of objects in the distributed system. The name
servers that store the information about an object are called the
authoritative name servers of that object.
 To determine the authoritative name servers for every named object,
the name service maintains authority attributes that contain a Jist of
the authoritative name servers for each object.

ATOMIC TRANSACTIONS
 An atomic transaction (or just transaction for short) is a
computation consisting of a collection of operations that take place
indivisibly in the presence of failures and concurrent computations.
 That is, either all of the operations are performed successfully or
none of their effects prevail, and other processes executing
concurrently cannot modify or observe intermediate states of the
computation.
 Transactions help to preserve the consistency of a set of shared data
objects in the face of failures and concurrent access.
 They make crash recovery much easier, because a transaction can
only end in two states transaction carried out completely or
transaction failed completely.
 Transactions have the following essential properties:

ATOMIC TRANSACTIONS
 1. Atomicity:
 This property ensures that to the outside world all the operations of a
transaction appear to have been performed indivisibly.
 Two essential requirements for atomicity are atomicity with respect
to failures and atomicity with respect to concurrent access.
 Failure atomicity ensures that if a transaction's work is interrupted by
a failure, any partially completed results will be undone. Failure
atomicity is also known as the all or-nothing property because a
transaction is always performed either completely or not at all.
 On the other hand, concurrency atomicity ensures that while a
transaction is in progress, other processes executing concurrently
with the transaction cannot. modify or observe intermediate states of
the transaction.

ATOMIC TRANSACTIONS
 Only the final state becomes visible to other processes after the
transaction completes.
 Concurrency atomicity is also known as consistency property
because a transaction moves the system from one consistent state to
another.
 2. Serializability:
 This property (also known as isolation property) ensures that
concurrently executing transactions do not interfere with each other.
 That is, the concurrent execution of a set of two or more transactions
is serially equivalent in the sense that the ultimate result of
performing them concurrently is always the same as if they had been
executed one at a time in some (system-dependent) order.

ATOMIC TRANSACTIONS
 3. Permanence:
 This property (also known as durability property) ensures that once a
transaction completes successfully, the results of its operations
become permanent and cannot be lost even if the corresponding
process or the processor on which it is running crashes.
 To easily remember these properties, Harder and Reuter [1983]
suggested the mnemonic ACID, where A, C, I, and D respectively
stand for atomicity (failure atomicity), consistency (concurrency
atomicity), isolation (serializability), and durability (permanence).
Therefore, transaction properties are also referred to as ACID
properties.

Need for Transactions In a File Service
 The provision of transactions in a file service is needed for two main
reasons:
 1. For improving the recoverability of files in the event of failures.
Due to the atomicity property of transactions, if a server or client
process halts unexpectedly due to a hardware fault or a software
error before a transaction is completed, the server subsequently
restores any files that were undergoing modification to their original
states.
 Notice that for a file service that does not support transaction facility,
unexpected failure of the client or server process during the
processing of an operation may leave the files that were undergoing
modification in an inconsistent state.

 Without transaction facility, it may be difficult or even impossible in
some cases to roll back (recover) the files from their current
inconsistent state to their original state.
 2. For allowing the concurrent sharing of mutable files by multiple
clients in a consistent manner.
 If file access requests from multiple clients for accessing the same
file are executed without synchronization, the sequences of read and
write operations requested by different clients may be interleaved in
many ways, some of which would not leave the file in the intended
state.
 Therefore, unsynchronized execution of access requests from
multiple clients, in general, results in unpredictable effects on the
file.

 Transaction facility is basically a high-level synchronization
mechanism that properly serializes the access requests from multiple
clients to maintain the shared file in the intended consistent state.
 The following examples illustrate how the transaction facility of a
file service helps to prevent file inconsistencies arising from events
beyond a client's control, such as machine or communication failures
or concurrent access to files by other clients.
 Inconsistency Due to System Failure Consider the banking
transaction of Figure 9.7, which is comprised of four operations (a1,
a2, a3, a4) for transferring $5 from account X to account Z.
 Suppose that the customer account records are stored in a file
maintained by the file server. Read/write access to customer account
records are done by sending access requests to the file server.

 In the base file service without transaction facility, the job of
transferring $5 from account X to account Z will be performed by the
execution of operations a1, a2, a3 and a4 in that order.
 Suppose the initial balance in both the accounts is $100. Therefore, if
all the four operations are performed successfully, the final balances
in accounts X and Z will be $95 and $105, respectively.

 Now suppose a system failure occurs after operation a3 has been
successfully performed but before operation a4 has been performed.
In this situation, account X will have been debited but account Z will
not have been credited.
 Therefore $5 vanishes because the final balances in accounts X and Z
are $95 and $100, respectively (Fig. 9.8).
 Successful reexecution of the four operations will cause the final
balances in accounts X and Z to become $90 and $105, respectively,
which is not what was intended.
 On the other hand, in a file service with transaction facility, the four
operations a1, a2, a3 and a4 can be treated as a single transaction so
that they can be performed indivisibly.

 In this case, if the transaction gets executed successfully, obviously
the final balances of accounts X and Z will be $95 and $105,
respectively.
 However, if the transaction fails in-between, the final balances in
accounts X and Z will be rolled back to $100 each, irrespective of
what was the intermediate state of the balances in the two accounts
when the failure occurred (Fig. 9.8).
 Therefore, in case of a failure, the balances of the two accounts
remain unchanged and the reexecution of the transaction will not
cause any inconsistency.

Concurrency control in distributed transactions
 Inconsistency Due to Concurrent Access
 Consider the two banking transactions T1 and T2 of Figure 9.9.
Transaction T1, which is meant for transferring $5 from account X to
account Z, consists of four operations al, a2, a3 and a4.
 Similarly, transaction T2, which is meant for transferring $7 from
account Y to account Z~ consists of four operations bI, b2 , b3, and
b4 .
 The net effects of executing the two transactions should be the
following:
 To decrease the balance in account X by $5
 To decrease the balance in account Y by $7
 To increase the balance in account Z by $12

 Assuming that the initial balance in all the three accounts is $100, the
final balances of accounts X, Y and Z after the execution of the two
transactions should be $95, $93, and $112, respectively.
 In a base file service without transaction facility, if the operations
corresponding to the two transactions are allowed to progress
concurrently and if the file system makes no attempt to serialize the
execution of these operations, unexpected final results may be
obtained.
 This is because the execution of the operations corresponding to the
two transactions may get interleaved in time in an arbitrary order.
 Two such possible interleavings that produce unexpected final results
are shown in Figure 9.10.

 The cause of the error is that both clients are accessing the balance in
account Z and then altering it in a manner that depends on its
previous value.
 In a file service with transaction facility, the operations of each of the
two transactions can be performed indivisibly, producing correct
results irrespective of which transaction is executed first.
 Therefore, a transaction facility serializes the operations of multiple
transactions to prevent file inconsistencies due to concurrent access.
 However, notice that the complete serialization of all transactions
(completing one before the next one is allowed to commence) that
access the same data is unnecessarily restrictive and can produce
long delays in the completion of tasks.

 In many applications, it is possible to allow some parts of multiple
concurrent transactions to be interleaved in time and still produce the
correct result.
 For instance, two possible interleavings of the operations of the two
transactions of Figure 9.9 that produce correct results are shown in
Figure 9.11.
 Any interleaving of the operations of two or more concurrent
transactions is known as a schedule.
 All schedules that produce the same final result as if the transactions
had been performed one at a time in some serial order are said to be
serially equivalent.
 Serial equivalence is used as a criteria for the correctness of
concurrently executing transactions.

Operations for Transaction based File Service
 In a file system that provides a transaction facility, a transaction
consists of a sequence of elementary file access operations such as
read and write.
 The actual operations and their sequence that constitute a transaction
is application dependent, and so it is the client's responsibility to
construct transactions.
 Therefore, the client interface to such a file system must include
special operations for transaction service. The three essential
operations for transaction service are as follows:
 begin_transaction returns (TID): Begins a new transaction and
returns a unique transaction identifier (TID). This identifier is used in
other operations of this transaction. All operations within a begin
fransaction and an end_transaction form the body of the transaction

 end_transaction (TID) returns (status): This operation indicates
that, from the viewpoint of the client, the transaction completed
successfully.
 Therefore the transaction is terminated and an attempt is made to
commit it.
 The returned status indicates whether the transaction has committed
or is inactive because it was aborted by either the client or the server.
 If the transaction commits, all of its changes are made permanent and
subsequent transactions will see the results of all the changes to files
made by this transaction.
 On the other hand, if the transaction was aborted, none of the changes
requested so far within the transaction will become visible to other
transactions.

 A transaction is aborted either on explicit request by the client or in the
event of system failures that disrupt the execution of the transaction.
 abort_transaction (TID): Aborts the transaction, restores any changes
made so far within the transaction to the original values, and changes
its status to inactive.
 A transaction is normally aborted in the event of some system failure.
However, a client may use this primitive to intentionally abort a
transaction.
 For instance, consider the transaction of Figure 9.12, which consists of
three write operations on a file.
 In Figure 9.12(a), all three operations are performed successfully, and
after the end_ transaction operation, the transaction makes the new file
data visible to other transactions.

 However, in Figure 9.12(b), the third write operation could not succeed
because of lack of sufficient disk space.
 Therefore, in this situation, the client may use the abort_transaction
operation to abort the transaction so that the results of the two write
operations are undone and the file contents is restored back to the value
it had before the transaction started.
 Notice that, once a transaction has been committed or aborted in the
server, its state cannot be reversed by the client or the server.
 Consequently, an abort transaction request would fail if a client issued
it after that transaction had been committed.
 In a file system with transaction facility, in addition to the three
transaction service operations described above, the transaction service
also has file access operations Tread and Twrite.

Distributed Deadlocks
 Deadlock is a situation where a set of processes are blocked because
each process is holding a resource and waiting for another resource
acquired by some other process.
 Consider an example when two trains are coming toward each other
on the same track and there is only one track, none of the trains can
move once they are in front of each other.
 A similar situation occurs in operating systems when there are two or
more processes that hold some resources and wait for resources held
by other(s).
 For example, in the below diagram, Process 1 is holding Resource 1
and waiting for resource 2 which is acquired by process 2, and
process 2 is waiting for resource 1.

 Deadlocks in distributed systems are similar to deadlocks in single-
processor systems, only worse.
 They are harder to avoid, prevent, or even detect, and harder to cure
when tracked down because all the relevant information is scattered over
many machines.
 In some systems, such as distributed data base systems, they can be
extremely serious, so it is important to understand how they differ from
ordinary deadlocks and what can be done about them.

 People sometimes might classify deadlock into the following types:
 Communication deadlocks :
 Competing with buffers for send/receive
 Resources deadlocks :
 Exclusive access on I/O devices, files, locks, and other resources
 Four best-known strategies to handle deadlocks:
 The ostrich algorithm (ignore the problem).
 Detection (let deadlocks occur, detect them, and try to recover).
 Prevention (statically make deadlocks structurally impossible).
 Avoidance (avoid deadlocks by allocating resources carefully).

Deadlock detection in Distributed systems
 In a distributed system deadlock can neither be prevented nor avoided
as the system is so vast that it is impossible to do so.
 Therefore, only deadlock detection can be implemented.
 The techniques of deadlock detection in the distributed system require
the following:
 Progress –
The method should be able to detect all the deadlocks in the system.
 Safety –
The method should not detect false or phantom deadlocks.
 There are three approaches to detect deadlocks in distributed systems.
 1. Centralized approach –
In the centralized approach, there is only one responsible resource to
detect deadlock.

 The advantage of this approach is that it is simple and easy to
implement, while the drawbacks include excessive workload at one
node, single-point failure (that is the whole system is dependent on
one node if that node fails the whole system crashes) which in turns
makes the system less reliable.
 2. Distributed approach –
 In the distributed approach different nodes work together to detect
deadlocks.
 No single point failure (that is the whole system is dependent on one
node if that node fails the whole system crashes) as the workload is
equally divided among all nodes.
 The speed of deadlock detection also increases.

 3. Hierarchical approach –
 This approach is the most advantageous.
 It is the combination of both centralized and distributed approaches
of deadlock detection in a distributed system. In this approach, some
selected nodes or clusters of nodes are responsible for deadlock
detection and these selected nodes are controlled by a single node.

Summary
 A file is a named object that comes into existence by explicit creation, is
immune to temporary failures in the system, and persists until explicitly
destroyed.
 A file system is a subsystem of an operating system that performs file
management activities such as organization, storing, retrieval, naming,
sharing, and protection of files.
 A distributed file system is a distributed implementation of the classical
time-sharing model of a file system.
 In addition to the advantages of permanent storage and sharing of
information provided by the file system of a single-processor system, a
distributed file system normally supports the following: remote
information sharing, user mobility, availability, and diskless
workstations.

Summary
 The desirable features of a good distributed file system are-transparency
(structure transparency, access transparency, naming transparency, and
replication transparency), user mobility, performance, simplicity and
ease of use, scalability, high availability, high reliability, data integrity,
security, and heterogeneity.
 From the viewpoint of structure, files are of two types-unstructured and
structured. On the other hand, according to modifiability criteria, files
may be mutable or immutable.
 The two complementary models for accessing remote files are remote
service model and data-caching model.
 In file systems that use the data-caching model, an important design
issue is to decide the unit of data transfer. The four commonly used
units for this purpose are file, block, byte, and record.

Unit – 4
Assignment Questions Marks:-20
 Q.1

Thank You
Great God, Medi-Caps, All the attendees
Mr. Sagar Pandya
www.sagarpandya.tk
LinkedIn: /in/seapandya
Twitter: @seapandya
Facebook: /seapandya

Distributed File Systems

More Related Content

What's hot (20)

Similar to Distributed File Systems (20)

More from Medicaps University (14)

Recently uploaded (20)

Distributed File Systems

Editor's Notes