 Hey everyone and welcome to the this class the LPS class today, we will be again continuing with the Linux networking lecture number 6, in the last lecture we just introduced the DFS today we will be going on with the DFS the distributed file system, in fact I am going to actually we will start the DFS discussion today, last time we just looked at some introduction but I am going to repeat that material again and before I begin I think like I mean we had a good lecture on the DNS system, we looked at the email last time I am not going to recap that today, if you have any doubts you can always take it up in the next session or so, so let us begin the discussion on the distributed file system, again as I mentioned in the last class we will talk about the distributed file system what it entails, why is it big deal, we will go into the architecture again we need to know like why it is a big deal again, what are the issues with the file system, what are the issues with the file system and also we will take up like two case studies one is on the Sun NFS system and then the other one is Andrew file system again let us see like I mean how far we can get to but these are the topics that I want to cover, so last time we discussed the file system again the file system basically it is it was done it was developed for a centralized computer system and the desktop computers and file system is an operational operating system facility providing a convenient programming interface to the disk storage, so we will see like what are the gradations of file system or we have to understand the memory architecture before we go into the file system and a distributed file system specifically it supports sharing of information in forms of files and hardware resources across the network, so that is the key thing and then once we have this system like Corba or Java in the web this entire thing basically like how much we are sharing and how the sharing happened has become like extremely complex, so before we go into the storage system let us look at just the memory architecture I think like I mean this is something that you are familiar with so we have say like I mean this box represents the of the CPU and then there is a cache memory which is part of the CPU which is very very localized and in fact you won't even know the existence unless you look at the computer itself or basically like what the chip has in the control panel or any other place basically typically these come in various sizes right now we have one gig two gig we all measure in in terms of gig actually then we also have the the main memory this is an example will be like the DDR3 is very famous nowadays you get in two gig 4 gig DDRs sometimes like even the caches like I mean it used to be like in case now probably like in megs and gigs are also available and the memory of course like main memory in a heavy duty server it can go all the way up to like one terabyte also then you have like hard disk which is essentially the storage where things get written and basically it resides the programs reside in the hard disk before they get executed a distributed storage is nothing but so if you look at this particular box the box around it is a system or a computer and then basically like a distributed system is centralized for storage and that is shared between multiple of multiple computers or there are multiple disks that can be accessed by a single computer all through a network so now I mean if you look at the hard disk and a distributed storage apparently they are all the similar stuff so what is the big deal in like using a distributed system so let us look at some of the challenges so when we talk about the distributed file systems there are many many challenges that that may need to overcome in order to make sure that we get we can reliably store and retrieve it one of the issues is the transparency so as you know the data is written in various chunks basically so what kind of data in a hard disk is transparent to the host systems is it all of them is it some portions are transparent to some of the systems and some portions are transparent to another system how is that divided and then when there is an overlap like what happens so these are some of the things that we need to worry about because there are many many systems accessing the same disk storage now so again that is one thing that we will talk about then the next issue will be the concurrency issue what happens is two servers or two clients access the same files concurrent who gets the preference and why so these are the kind of questions that we ask about concurrency then the other one is replication which is when the server the file in a server changes can all the time see the change immediately or do they have to wait how do how does that work so again that is another thing that we will talk about then the fourth challenge is the heterogeneity challenge again in this one is whether the file system support multiple OSS so I am coming I am connecting with Windows OS somebody else is connecting with Linux OS somebody else may be connecting with the iOS OS how does the system behave in that sense and does it support all the OSS or supports some of the operating system how does it work then the other challenge is the fault tolerance challenge which is when the file system crashes how does the client know about that or if the client crashes how does the file system react say like I mean you are writing to a file area and then that the client crashes now what happens do that that that that area gets recovered or is it just all corrupted how does how what what what happens then the other one is consistency consistency comes from the different clients then they access basically the is that the what each client looks at from each perspective are they all in consistent view so that is another thing basically that we will talk about and then the security is another concern how do you authenticate a client or a user to a file system and so that I mean he can only he can access we saw like some of the high level issues regarding security in when we studied about the Linux basically next OS where we talked about the read write access read write execute access how does that work so here we will be that that challenge has been multiplied pretty heavily so we will look at that and then finally efficiency how do we keep wastage of the space to the minimum so are these techniques that we can employ to do this what do we do so again as I mentioned the classical examples are this some manifest from the Android file system so we will be learning about all these things so before we go into that let us look at the the main memory architecture which is essentially we saw this in the previous slide so let us look at it from the main memory onwards so we are not looking at the caches and inside whatever is inside the chip so main memory it is not it is not a shared memory mostly like it is local to that particular machine or that particular CPU and the persistence it is not persistent so persistence is another property essentially for the the data whether then the process die whether the data still stays there or not so usually what happens is whatever the program that is running in a process writes out the data into the hard disk so that the main memory is completely cleared of any of the remnants of that that particular process so so so what that means is basically the main memory more persistent memory so we do not keep anything after the process gets executed then by nature main memory is also similarly is very local localized memory so we do not keep any distributed cache or replicas so that is also no then the consistency maintenance again it tries to maintain the consistency and the the example essentially but it says there is still a one copy consistency for that you cannot replicate that copy across multiple main memory systems here we will call it main memory systems example is that RAM or the DDR is another one so those kind of things now let us look at file system file system again like you do not allow the file system to share but it is persistent meaning the data gets written into that file system after the process gets executed again I am distinguishing between program and process that this is the distinction that we saw very early in the course which is essentially the process is a running instance of a program I hope you guys remember again the file system also does not allow distributed or cached replicas because inherently like in this file system we are talking about is a file system within the computer so it is mainly for that particular machine again consistency maintenance is a quickly like one copy consistent system now let us talk about the distributed file system this is this is where it gets interesting we allow sharing in a distributed file system the data is persistent as we know and then it also allows the distributed cache essentially so that you can create replicas of data all over the place and finally the consistency maintenance is we will have multiple copies which essentially go through that consistency so we call it like approximate consistency so we know that I mean consistency is how each of the client will view that particular files and here it is it is almost there essentially some of the new information may not be there in the file but pretty much like I mean the copies are updated on a periodic basis so now let us look at a web server web server also allows you to share the data it is the data is persistent allow the distributed cache and replicas but there is no consistency essentially like if something gets updated everything is not looking at the same thing so one data may be old the other data may be new unless you keep like refresh the data won't be updated the distributed shared memory is another one so here again allow the share sharing of the memory but the memory itself is not persistent the way that we allow the memory is also through the distributed cache and replicas and then finally the consistency maintenance is also there remote objects essentially this is something that the corba supports and again here sharing is done and then it is just a one copy consistent so if you look at it I mean so the highest one is probably the distributed file system and then there is also the peer-to-peer storage system which is also very similar but the others are kind of they are lower in the hierarchy as you can see the persistent object store and also the the remote objects from the corba so let us look at the the next picture this shows like a layered more modular module structure for the implementation of a non-distributed file system so here we have a directory module and then a file module then the access control module file access module a block module and the device module so let us let us just look at what each the function of each of them the directory modules is essentially like I mean that has all the file handles that are in that particular direction so this is the each of the file IDs the file handles are also known as a file ID so essentially the file names are related to the file ID with using the direction module the file module keeps all the the file IDs and correspondingly like body the file where is it located and all those details the access control module is the permission checker we already know that there are three types of permission the read write and execute so the access control module is the one that checks for these permissions and whether certain operations are allowed or not allowed the file access module that essentially is used to read and write file data or the attributes and the block module essentially like now accesses the file system or essentially the disk and that goes and allocates the blocks that are needed for this writing the file and then so basically like I mean the blocks are usually chunks of some number so that based on the file size or estimated file size it allocates some blocks for the particular file in the memory and then the device module is essentially like I mean now that is pretty much it is the module that accesses the disk does the I use and also like the buffing so whenever you are reading the file it takes the file ID essentially like I mean that particular disk and it gets the file for the through the buffers it takes the buffers again the file systems essentially like I mean so that provides the organization storage retrieval naming sharing and protection of all the files so a file contains the the data and the attributes so now let us look at how the file records are record structure or how a file record structure looks like so the key things that we want to write are the file length and then it was created a creation timestamp if it is read multiple times or when was the last time it read it is read that is a read time timestamp after creation when if it is written again then the writes timestamp and then there are some attribute timestamps and then the reference counts and then there are some additional ones which is the owner the file type and then the access control list so this is typically the record that is kept as part of the file and we can actually access various various form parameters to get to where what the value is so these are done through the operations essentially so let us look at some of the operations so here the operation is open open is the name and then the mode so it basically opens an existing file with a given name and then assigns the file ID to file destination create is another operation with the name and the mode and this one creates the file with the name in that that ID is assigned to the file ID file this so the the mode can be like read write or read write and then close the file destination or the file handle closes that particular file in any of the open files and then if it can close then it assigns the status as 0 and if it cannot close then the status becomes 1 so based on the return value we can decide whether the file not closed or not and then the count essentially like I mean this is actually like I mean the operation is the read operation read file this buffer n it essentially transfers n bytes from the file to the buffer and essentially like we can also like measure that in the count now the write again file destination buffer n will transfer the file actually like I mean the the n number of bytes are transferred from buffer into the file that so these operations essentially like I mean they deliver the bytes and they also advance the read write pointer so the pointer is essentially like I mean what is in the file so that you know like I mean where exactly that is and then L seek is given offset and the and another param called when using this parameter it goes and moves the pointer the read write pointer to that offset and then unlink essentially like removes the file name from the directory structure if it has no other names it is just deleted otherwise it is basically like it just removes that name alone the other names are kept and link name one name two again this adds a new name or name two to the file name one and then the other one is the stats command this actually gets all the file attributes we saw that here essentially this one the attribute count and then the attribute time step so in all the attributes are it is taken and then put it in the buffer so we already saw like I mean so the requirements itself like I mean we know that these are the challenges and that is what we need so let us look at the file service architecture this actually offers a clear separation of the main concerns in providing access to the files and it is obtained by structuring the file service in the three components so there is a flat file service a directory service and the client module service so again this the file service architecture is a way to organize the services that are associated with the files so that things are provided properly so now let us look at the modules in the file service architecture so imagine the server computer sitting somewhere far away and then they it is connected to the client using this link is essentially like some kind of the network and there may be like more clients sitting there which are accessing the same data and essentially like I mean so when the client tries to access the flat file service essentially like I mean it is just associated this and directly like I mean it collects the data and sends to the client and it is almost like I mean you can think of here the client computer is accessing just as a one-on-one with interacting with the file services so there is a directory service and a file service and basically like the flat file service collects that file information sends it to the flat so essentially in a flat file service all the the files are assigned a unique file identifier or UFID and so since the file themselves are uniquely named it is easy to actually obtain what the file is and essentially like I mean so one system that is accessing one of the files the other systems may not be able to access that same thing every every file has a unique identifier and the clients need to know that unique files identifier in order to access that file so the client there is a client module that exports the interfaces by the flat file and the directory services from the server side so the directory service itself it is provided it provides the mapping between the text names of the files and their UFID so the clients may obtain the UFID of a file by coding its text name to the directory services and these are all like one-to-one mapping so so that that is the uniqueness of the flat file service it is not very interesting and as you can see actually the UFID can be a long sequence of bits because if we need to map all the files in the file system with unique identifier it is kind of an obvious task anyway so the client module that is another piece of the services that we saw in this picture this runs on each computer and provides an integrated service or a flat file service because this service is pretty much constant or same across all the clients so the client service in fact in the unique side actually emulates the full service full set of unique file operations these are the operations that we saw like earlier like open close and all those things all of the services are provided by the client module it also holds the information about the network locations of the flat file and then the directory server processes so that it can actually go to those directory servers and access those files very easy it actually is better performance through implementation of a cache of recently used file block at a client so we can improve the performance of plan module by having a cache a local cache within that particular client in the system that we store the recently used file block again the issue will be how do we maintain the consistency and so we will talk about that so here some of the again commands that we can use the read field i, n and then that goes into data essentially so this is a dash and arrow data here essentially like I mean we read a sequence of one through length of file and the variable is i which is essentially like increment that and then basically like when and then essentially like when that particular items are stored in data the write field i data essentially it writes a sequence of data into a file starting at item i and extending the the file if necessary and create is another command that creates a new file with length 0 and delivers a ufid to the field variable and delete field just remove that file from the file store get attributes field and then store we can store it into another variable called attribute and then set attributes essentially like I mean that essentially like whichever attribute that you specify is set to that particular field which is essentially I mean sorry file ID which is the the unit ID that we have found out so again the access control so in the distributed implementation access write checks has to be performed at the server so it is not a client that provides the access control because the remote process control interface is unprotected point of access to these files essentially so until you reach the server basically like it is all unprotected and then basically looks for the access control itself is provided at the server side directory service interface essentially like in that we will look into it now so here there is a look up for particular directory with the name and that returns a file ID and if the name itself is not there in the in that particular directory then it throws an exception so that is the throws not form in the add name essentially like add the name and call the file into the particular directory and if there is a already that name exists then it throws an exception unname directory name is essentially like the name is in the directory then it is removed from the directory if it is not there in the directory then it throws an exception and then finally the get names directory pattern get the text names in the directory with a match of the regular expression pattern we will learn about regular expression in the future modules in one of the programming modules and then that is assigned to the essentially so now we go into the the next file service architecture which is hierarchical file system so right now we look at this a flat file which is very easy to implement very easy to access but at the same time you cannot do a lot of functionality there and also you need to carry along the unique file identifiers which just causes issues by growing your directories and growing the client modules now let us go into the next one which is the hierarchical file system this is essentially like I mean is the file system where the the directories are now arranged in a tree essentially so essentially like you need to go into like various directories in order to figure out what is going on and then also the file group is another concept there where it is a collection of file that can be located on any server or moved between the servers while maintaining the same names so we saw some of these examples in the originally like started Linux a similar construct is used in the in a unique file system it helps with distributing the load of file serving between the servers so essentially like I mean you can move the file system or the file group to be closer to where the clamp is asking for so you can move to one of the servers also the file groups have identifiers which are unique throughout the system so that is that is the way that it can be moved from one system to the other so here is one method to construct a globally unique ID so we just use some attribute of the machine on which it is created so basically like the IP address so we know that IP address is 32 bit or a four-acted binary we just add a date to it like so the IP address followed by date we call it as a unique identifier the date could be a date and time all the way to the second then the file gets created so now we go into the distributed file system so again the three hierarchies that we talked about are the three different types of file system that we talked about the flat files the hierarchical files and now we go into a distributed file system so here we will talk about two main file systems one is the NFS of the Sun NFS this is the this was developed by Sun macro system in 1985 it is the most popular and it is open file system and it is used pretty much universally today also the NFS protocol itself is standardized through this particular standard is known as the RFC 1830 so the main idea is the here is basically the server the file system itself is a stateless system so essentially like I mean the server itself is not required to remember anything so it does not have anything in the memory essentially the things like which clients are connected which files are open things like that so essentially like I mean just the file system itself is sitting in one place the signs basically are sends some requests essentially with all the information that are needed and then basically the server just fulfills the request and then this forgets the minute it fulfills the request and then moves on so the onus is on the clients to provide all the information that are needed for accessing a file or essentially need to provide that to get that service so the whole so the advantage of this kind of a system is that the server state does not even does not grow with more number of clients so there is no change to the server itself which you need to change the number of service and then the other key idea of NFS is then you perform an operation and if you are repeating the operation you get the same result there are no side effects so essentially like I mean if you say like a equal to b plus 1 and then essentially like every time you do the a basically like I mean it is always it you get only like a equal to b plus 1 or you do not get a equal to a plus 1 there now the state of a is different so that the next time you when you query it is a different answer the second system that we will study is the ASS of the Andrew file system this is developed by the Carnegie Mellon University as a part of the Andrew distributed computing environments in 1986 so you can see that actually they are fairly close the this research project was to create a campus wide file system and basically a public domain implementation is available on units it is called the Linux ASS so this was again also adopted as a basis for the DSS system DSS file system in the open software foundation and the distributed computing environment essentially so let us look at the NFS architecture the NFS architecture consists of again the client computer but as I mentioned the client has a lot of owners on providing the data so let us look at first the server computers server computer has nothing but a virtual file system which has the which holds the unique the unique file and then it has an NSS server which is another program that serves the various clients and then in the client computer again like I mean you have the same kind of things there is a virtual file system which has the unique file system and then whatever the extra ones here basically the blank ones are various devices slash depth and then there is also an NFS client the NFS client talks to the NFS server basically and provides the information as what the files that it retrieve it wants to retrieve or write the write the content into that file they all these programs actually like they all the same under the Linux software in external the communication between the the client and the server are using RPC what are what is known as the remote procedure files essentially so the client itself basically it is a it is a transparent access to the NFS file system so when you go through this NFS client to the NFS server since it is stateless basically like it has it like this is now connected together and there is no NFS server and then a plan and basically it is just you can transparently access whatever is inside the unique file system server side as well so the client's job is essentially like going to basically provide this file system and also the transfer and access to the NFS it also provides some virtual nodes essentially which is essentially like procedures for procedures on an individual file or it is an interface for procedures on an individual file and then basically it translates that the individual file procedures into the various NFS remote procedure calls so that way like I mean it can access the NFS server and retrieve that file so here essentially like the application program provides the unit system calls through the unit's kernel and essentially like I mean the operations so they all the virtual file system just keeps all the operations as a local operation so you won't feel that actually there are some remote files also so from the application side you are just calling a local program but the virtual file system identifies which is the local and which is the remote files and then the remote files are handled to the NFS client and then it provides this RTC into the NFS server to retrieve that file so the file identified we already introduce this concept of a file handle the file handle is the file identifier that I use in the the NFS itself so here a particular file handle denoted as FH could be the file system identifier the the node number and then the I node generation so so all the all of them are combined together to get to the file handle so the various commands are used here so in this one there is a read operation we again like very similar to the flat file access give the file handle or the file ID the offset and the count and then that retrieves the data and put it in the the data variable the write for writing basically we give again the file handle the offset the count and then the data and then basically like a minute is written into the file system and then basically like this an attribute that is written the create command essentially where we specify a directory file handle the name and then the attribute and this command returns a new file handle and also some attribute attribute on the file and then the remove actually is remove just return the status the remote or not again we give the just directly file handle and then the name by name the get attribute file handle gets the attribute related to that particular file then the set will set that then there is a lookup command essentially which returns the file handle and then the attribute rename command it is basically the original name or the from directory file handle and the name to the to directory and then to name link provides a link to the existing file then the read there essentially read the particular directory and then returns all the value into this variable entries same link is a symbolic link you are a soft link which ties a file to another and new name and then that returns the status the read link file handle essentially like that returns a string essentially so it gives this back is the expanded link path make there is it creates a new directory and for that it gives you the new file handle and then Rmder basically removes a directory and then stabbed file system file handle gives the file system status essentially so these are some of the commands that are used in the some NFS which is one of the very popular system. So now let us look at some of the other features of some NFS in fact we learned about this one one is the security or how do we make sure that there is an access control and authentication so as I mentioned earlier the NFS server itself is a stateless server which means that the user's identity access right all of them are controlled by the server only on the request and essentially the client is so the local file system they are checked only on the files access permission attribute so essentially like I mean this is beam we have to check every time whenever we access the file system so it does not remember like I mean a particular user is authenticated or not so every time you need to check again and again also the client request is accompanied by a user ID and the group ID these are inserted by the RPC so the remote procedure call we talked about this also like earlier like example there the virtual file system converts or basically like it forwards the remote access to the NFS client which converts the file handle into the particular remote principle which contains these additional data which is the user ID and the group ID and then then it sends it to the file system to gather that so the Kerberos is also it has been introduced it has been integrated with NFS and that provides stronger and much more comprehensive security so now let us look at the mount service mount service is used to mount a particular disk into the file system so if it is a new disk we use the mount function to do this to mount the remote files so the operation is mount remote host remote directory and the local directory so it basically like mounts that file system into the local directory in this example the server maintains the table of clients whichever ones mounted the file system each client maintains a table of mounted file systems holding the IP address the port number and then the file handle the remote file systems may be hard mounted mounted or soft mounted in a client computer very similar to the soft link or hard link so here another example where it shows the two remote mount files so in the server there is a directory called people which contains like big John and Bob in the client side there is a directory called user which has students which are remotely mounted on people and then there is also another directory of staff which is a remotely mounted on staff in actually in users in so too then there is also a concept of auto monitor the auto monitor was added to the unique implementation of NFS in order to mount a remote directory dynamically whenever an empty mount point is referenced by a client so this is kind of the client ask for a particular node which is empty by default then the auto monitor automatically mount the particular remote directory there so again the auto monitor has a table of mount points with the reference to one or more NFS servers listed against each so it sends first a probe message that each candidate server to see whether the particular mount point is still available then it uses the mount point to mount the file systems and then serve the apartment and usually the auto monitor keeps the mount table to be very small so this also provides a form of replication for read only files so let us look at the caching essentially recommend so caching can be of two forms one is a server side caching and then also the other one is the client side caching before we go into the server side caching let us look at the client side caching the caching always is it provides improved performance because certain blocks if you cache and basically goes out of the lock and the client request that every time the cache can provide very quick access to that particular block so that the system that is requesting that is not starving for data so for reads essentially like I mean for the always the the protocol from the client side is checks with the local cache before goes into the server because whenever we go into servers it can take longer time whereas the local cache will be easier so only if there is a cache miss it goes to the server but at the same time writes basically you can the most or the Sun and X itself provides the periodic writeback and not an immediate writeback to the server mainly the the reason is we do not want to contact server that often because that can slow down the communication network so the client caches two types of data the one is the data block itself and then the other one is the actual now let us look at the server caching basically so the server caching is very similar to the unit side caching in the local form so the various blocks from the disk they are held in the main memory buffer cache until the space is required for new pages the read ahead and delayed write optimizations are also possible so what this means is basically so if you know that actually you are reading from one particular file instead of getting the portions that are in the read operation you get more thinking that maybe like I mean you can read ahead of time so and then delayed write is essentially like I mean so you delay the write with either the various cache consistency protocols and so that we can further optimize overall caching can for the local files the writes are deferred to the next single so this is again the delayed write so 32nd interval is when like the sink even happened it the way that in the Sun NFS both very well with the local context the files are always active to the local cache but in a remote case the synchronization like it does not guarantee the necessary synchronization to the cache so the NFS version 3 servers offers two strategies for updating the disk one is the write to and then the other one is the delayed commit I think like you already know about this when we had studied the cache coherency protocol how to maintain coherency in a cache whereas the write to is essentially again writing it both in the cache as well as in the main file in this case essentially like I mean for the altered pages are written into the disk as soon as they are received at the server so then the other one is the delayed commit whereas the pages are held in a cache until a commit signal arrives and then basically at that point the file system itself is written with the new beta so we we looked at from this client caching so again the client caches the results from the read write get attribute look up and then the reader operations the synchronization is not guaranteed when two or more clients are sharing this so that is something that we pay the penalty for then the validity itself is checked through a timestamp based check essentially like it reduces the inconsistency but it does not eliminate it so it is used for the validity condition condition or cache increase at the plan so formula is like T which is the parent time minus TC the time when the cache entry was last validated must be less than T which is the person is guaranteed so we do not want excessive time pass between these two events to do anything kind of thing and then essentially the TM client is the time and the block was last updated at the server and then basically TM TM server is essentially like then so actually TM client is the time in the block was last updated at the client and then the same thing is when it was a server TC is the time and the cache entry was last validated so so basically like I mean we need to make sure about this is the validity condition that is satisfied for the cache entries so in the previous one the the T perf is it is the freshness guarantee that can be customized so you can decide what that value should be and then based on that we can construct the the rules so the T is set between like three seconds to 30 seconds also it remains difficult to write distributed applications that share files with the so one other question that may come up is how do we maintain the how do we update or how does client update the server so for files essentially like I mean we can do the write back from the client cache to the server and then we can decide that into the last 30 seconds also like there are commands called flush on close which is essentially it takes the the memory needs and writes and then push it into the file system automatically for the directory is essentially like we just continuously write to a server so as an example we can say okay the client X and Y they have a file name called a that is cached and then the file name a occupies the block 1 2 and 3 so now the clients X and Y both can open a and then X writes to the blocks one and two and then client Y actually like now it writes to the block and block one and 30 seconds later what happens the client Y reads blocked it and 40 seconds later the client Y reads block one so again like I mean this is one scenario like I mean there you can find out how system will behave so the performance itself is another parameter or another concern that we talked about so the right operations only like I mean responsible of 5% of the server cost in the typical units and moments the lookup accounts for 50% operation because step-by-step part name resolution is necessitated by the naming and then the model semantics so the recent measurements show a higher performance of the NFS and then the last measurement was taken in 1992 so in summary NFS is an excellent example of a very simple but a robust high performance distributed service or a distributed file system so the access transparency essentially like I mean for the same Unix call is or the Unix call itself is same for both local and remote files so that is one of the things we talked about in the transfer so let us look at those the transparency in detail so the location transparency the naming of the file systems is controlled by the client mounting operations but the transparency can be ensured by the appropriate system part duration so even though like I mean the client actually controls the month operations and how to name the files the transparency can be controlled if you actually configure the system with the appropriate information or uniqueness in the more points the mobility transfer transparency essentially means that when the system is changed from one to the other how do we ensure the transfer transparency this is not achieved at all and relocating the files is not possible and only the file systems are possible but that requires an update the client populations because clients are the ones deciding everything about the this particular file system memory loss and then the scalability transparency essentially like I mean for again this one we can subdivide the file systems and allocate and we can allocate separate servers for each of the file systems so that way like I mean we can scale the but it also depends the performance itself is determined by the load on the forward holding the most heavily used replications is another one so so for replication since we do a limited only we limit this file system to read only file systems basically the replication transfer system so for writable files the Sun network information service of the NIS one covering method and that is used to replicate essential systems the hardware software operating system heterogeneity again the NFS has been implemented for almost every known operating system and hardware platform and that is supported by a variety of high-end systems all tolerance it's limited but effective so service is suspended if the server fails victory from failures is aided by a simple state and efficiency basically it can be implemented for use in situations that generate a very heavy load so the next case study will be the Andrews file system before we go into that also want to talk about a little bit on the the Sun NSS file system so the key take away is that you want to take away our number one is it's a stateless server and then the operations themselves are what is known as the item potent operations what I mean is here yeah and then the other take away is also the the client so so yeah so the item put and server operation is essentially like I mean when you repeat an operation it does not have any side effects so it also helps with the ways other things basically like the fault tolerance the scale before common consistency they are all addressed in the NSS system and then one thing to note is when particular system crashes it tends to slow the other the server to the other plants the plants that are there so this is kind of one of the drawbacks of the pink of it and then the client also like needs to cache the data for scalable performance not just the server alone needs to catch in fact when server caches sometimes it is not me and since we put a cache in the client side the data consistency is extremely hard because now we don't know like in which copy is the latest form because there is some other copy that is still sitting in the processor so that's all I have for today you will continue from this point next week then we will bring the next pass thank you very much