Search

In a UNIX-type operating system, the VFS mechanism enables multiple different file systems to be used on one computer. However, when the VFS mechanism is used, the various file systems must be discriminated by using individual directories. Therefore, multiple file systems cannot normally be mounted on one directory and used properly. As a result, file systems having various features such as NFS or tmpfs are not used efficiently enough. In the current research, the authors respond to this problem by proposing the TAKFS file system, which superimposes the name spaces of multiple arbitrary file systems in the same directory to enable those file systems to be handled trans-parently. TAKFS transparently and automatically apportions actual files among the various file systems according to a combination of parameters and settings made in advance by each user indicating the files that are to be placed in each file system. If TAKFS is used, a flexible and extremely convenient system can be constructed by using currently existing file systems without changing them at all. © 2006 Wiley Periodicals, Inc. Electron Comm Jpn Pt 3, 89(9): 22–33, 2006; Published online in Wiley InterScience (www.interscience.wiley.com). DOI 10.1002/ecjc.20276

Knowledge of the file size distribution is needed to optimize file system design. In particular, if all the files are small, the disk block size should be small, too, to avoid wasting too large a fraction of the disk. On the other hand, if files are generally large, choosing a large block size is good since it leads to more efficient transfers. Only by knowing the file size distribution can reasonable choices be made. In 1984, we published the file size distribution for a university computer science department. We have now made the same measurements 20 years later to see how file sizes have changed. In short, the median file size has more than doubled (from 1080 bytes to 2475 bytes), but large files still dominate the storage requirements.

This paper describes a strategy to optimize small file's reading and writing performance on traditional distributed file system. Traditional distributed file system like GlusterFS stores data within local file system (XFS, EXT3, EXT4, etc.), which shows a significant bottleneck on file metadata lookup. We try to re-design metadata structure by merging small file into large file, thus to reduce size of metadata, so we can store the whole files' metadata inside main memory. We design and implement the whole strategy on GlusterFS, test results show a great performance optimization on small file operation.

The File Allocation Table (FAT) file system is widely used file system in tablet personal computers, mobile phones, digital cameras and other embedded devices for data storage and multi-media applications such as video imaging, audio/video playback and recording. The FAT file system is not power fail-safe. This means that, the uncontrolled power loss or abrupt removal of storage device from computer/embedded system causes the file system corruption. The TFAT (Transaction safe FAT) file system is an extension of FAT file system to provide power fail-safe feature to the FAT file system. This paper explores the design methodologies of cluster allocation algorithms of TFAT file system by conducting various combinations of file system operations in Windows CE (Compact Embedded) 6.0 Operating System (OS). This paper also records the performance bench-marking of TFAT file system in comparison with FAT File system.

In this research, we designed and implemented Real-World File System (RWFS), which can manage files as if we can put them onto or pick them up from the places of the real world. RWFS regards the places of the real world as directories of the file system by associating a directory with a place. We create directories called Real-World Directory (RWD) which forms a hierarchical structure to reflect the natural property of places. In addition to the conventional access rights of read, write, and execute as implemented in other file systems, RWFS accommodates utilizing location information of the target user in access rights; RWFS can decide whether or not the user can access to a particular file or directory based on the user's location. Therefore, accessible files for a user change depending on the user's location. This mechanism enables creating information that can be read or written by users who physically stay at a particular place. We evaluated this system by measuring turnaround time to operate the file system together with simulation.

Distributed file systems are used in distributed systems to support scalable storage and to enable the parallel and distributed processing of data. Sharing the data stored in the distributed file system among authorized users is a major requirement of the distributed file system. Popular distributed file systems use session semantics to share the data among the users. In this paper, we have proposed a read algorithm developed based on speculative semantics which permits the read process to read the updates done by the concurrent write process from the distributed file system provided such a reading does not affect data consistency.

As videotape gradually disappears from the broadcast plant, storage in a digital file format becomes more important. In most cases, this is a combination of spinning disk and removable media, either data tape or DVD. With that comes the management of material as it moves from video server to nearline to archive, and back again. The class of software products that perform this function are generally called hierarchical storage management or HSM systems. This is actually a misnomer, in that, HSM refers to a specific type of storage management rather than a product category. HSM is often used as a catchall term for two categories of file management: storage management and file backup. Storage management really consists of four broad subcategories of products, each having advantages and disadvantages, as it applies to on-air, production, and news environments. Specifically, the subcategories are shared file systems, HSM systems, disk extenders, and data movers. Related to, but completely different from storage management is file backup, which also often gets included with HSM. In the category of file backup are subcategories of mirroring, simple backup, and disaster recovery.

This study proposes a technique of accessing applications from multiple file servers in a computer network that caters for a large user community. The technique is a step towards creating a computer network system that is simple to implement, scalable, easy to manage, transparent to the user and suitable for a university-type environment. The proposed technique has some features of a distributed system, but is not as complex. It is built around a very popular commercial network operating system called NetWare.

Multiprocessing environments such as Unix are susceptible to race conditions on the file space, since processes share files in the system. A process accessing a file may get unexpected results while executing in a critical section if the binding between the file name and the file object is altered by another process. Such errors, called time-of-check-to-time-of-use (TOCTTOU) binding flaws, are among the most prevalent security flaws. This paper presents a model that detects TOCTTOU binding flaws by checking the integrity of bindings between file names and file objects at run time and a simplified prototype of the detection model. We discuss the properties of the detection model and its run-time overhead, based on the results of experiments on the prototype .

Arbre is a file system that guarantees the integrity of the entire file system on an untrusted remote block-level storage system with a small amount of trusted storage. Arbre does not require changes to the remote block-level storage systems commercially available today. Even if an unauthorized person manages to get complete access to the storage system, they cannot modify or replay any data without being detected. This is achieved by organizing all file system blocks as a single tree and storing their hashes as a part of metadata to later verify the correctness of their contents.

The CSFS (cryptographic storage file system) is a network file storage system that is suitable for a small-to-medium sized networks such as a campus network. In a CSFS, a lot of distributed file servers are organized in a star-liked architecture. File names are stored in a name server and file data are stored in distributed file servers. A CSFS has good scalability and is able to accommodate hundreds of file servers. We implemented a CSFS in pure Java and tested the system with a benchmark. The test results show that CSFS delivers acceptable performance for general file operations. Its performance of file upload and download is as efficient as FTP. It can support more than 450 concurrent online users. Copyright © 2005 John Wiley & Sons, Ltd.

NanoFS is a novel file system for embedded systems and storage-class memories (like flash) and is specially designed to be directly implemented in hardware. NanoFS is based on an original internal layout intended to achieve an optimal hardware implementation of the file system's file lookup and data fetch operations. File system specification on a sample reader module completely implemented in a programmable device is introduced.

This paper presents a solution for the broadcast file system based on digital storage media command and control (DSM-CC) data carousel protocol. Given the complexity of the object carousel protocol, we innovatively modify the data carousel protocol so that the hierarchical directory structure can be transmitted. The corresponding software has been implemented in set-top boxes. With the help of the virtual filesystem switch (VFS) mechanism, the broadcast file system can be accessed through unified interfaces. Considering the differences between the broadcast file system and the traditional file system, this paper also proposes the optimized strategies while receiving and caching data from the network in order to show better performance.

MOSIX is a cluster management system that supports preemptive process migration. This paper presents the MOSIX Direct File System Access (DFSA), a provision that can improve the performance of cluster file systems by allowing a migrated process to directly access files in its current location. This capability, when combined with an appropriate file system, could substantially increase the I/O performance and reduce the network congestion by migrating an I/O intensive process to a file server rather than the traditional way of bringing the file's data to the process. DFSA is suitable for clusters that manage a pool of shared disks among multiple machines. With DFSA, it is possible to migrate parallel processes from a client node to file servers for parallel access to different files. Any consistent file system can be adjusted to work with DFSA. To test its performance, we developed the MOSIX File-System (MFS) which allows consistent parallel operations on different files. The paper describes DFSA and presents the performance of MFS with and without DFSA.

This paper describes a novel technique for establishing a virtual file system that allows data to be transferred user-transparently and on-demand across computing and storage servers of a computational grid. Its implementation is based on extensions to the Network File System (NFS) that are encapsulated in software proxies. A key differentiator between this approach and previous work is the way in which file servers are partitioned: while conventional file systems share a single (logical) server across multiple users, the virtual file system employs multiple proxy servers that are created, customized and terminated dynamically, for the duration of a computing session, on a per-user basis. Furthermore, the solution does not require modifications to standard NFS clients and servers. The described approach has been deployed in the context of the PUNCH network-computing infrastructure, and is unique in its ability to integrate unmodified, interactive applications (even commercial ones) and existing computing infrastructure into a network computing environment. Experimental results show that: (1) the virtual file system performs well in comparison to native NFS in a local-area setup, with mean overheads of 1 and 18%, for the single-client execution of the Andrew benchmark in two representative computing environments, (2) the average overhead for eight clients can be reduced to within 1% of native NFS with the use of concurrent proxies, (3) the wide-area performance is within 1% of the local-area performance for a typical compute-intensive PUNCH application (SimpleScalar), while for the I/O-intensive application Andrew the wide-area performance is 5.5 times worse than the local-area performance.

Repository for continuous media data differs from that of the traditional text-based data both in storage space and streaming bandwidth requirements. The file systems used for continuous media streams need to support large volumes and high bandwidth. We propose a scalable distributed continuous media file system built using autonomous disks. Autonomous disks are attached directly to the network and are able to perform lightweight processing. We discuss different ways to realize the autonomous disk, and describe a prototype implementation on a Linux platform using PC-based hardware. We present the basic requirements of the continuous media file system and present the design methodology and a prototype Linux-based implementation of the distributed file system that supports the requirements. We present experimental results on the performance of the proposed file system prototyped using autonomous disks. We show that the performance of the file system scales linearly with the number of disks and the number of clients. The file system performs much superior to NFS running on the same hardware platform and can deliver higher raw disk bandwidth to the applications. We also present bandwidth and time sensitive read/write procedures for the file system and show that the file system can provide strict bandwidth guarantees for continuous media streams.

Parallel file system solves I/O bottleneck to store a file distributedly and read it parallel exchanging messages among computers that is connected multiple computers with high speed networks. However, they do not consider the message characteristics and performances are decreased. Accordingly, the current study proposes the Hybrid Channel model (HCM) as a message-management method, whereby the messages of a parallel file system are classified by a message characteristic between control messages and file data blocks, and the communication channel is divided into a message channel and data channel. The message channel then transfers the control messages through TCP/IP with reliability, while the data channel that is implemented by Virtual Interface Architecture (VIA) transfers the file data blocks at high speed. In tests, the proposed parallel file system that is implemented by HCM exhibited a considerably improved performance.

This paper presents Clusterfile, a parallel file system that provides parallel file access on a cluster of computers. Existing parallel file systems offer little control over matching the I/O access patterns and file data layout. Without this matching the applications may face the following problems: contention at I/O nodes, fragmentation of file data, false sharing, small network messages, high overhead of scattering/gathering the data. Clusterfile addresses some of these inefficiencies. Parallel applications can physically partition a file in arbitrary patterns. They can also set arbitrary views on a file. Views hide the parallel structure of the file and ease the programmer's burden of computing complex access indices. The intersections between views and layouts are computed by a memory redistribution algorithm. Read and write operations are optimized by pre-computing the direct mapping between access patterns and disks. Clusterfile uses the same data representation for file layouts, access patterns, and the mappings between each other.

Pangaea is a wide-area file system that supports data sharing among a community of widely distributed users. It is built on a symmetrically decentralized infrastructure that consists of commodity computers provided by the end users. Computers act autonomously to serve data to their local users. When possible, they exchange data with nearby peers to improve the system's overall performance, availability, and network economy. This approach is realized by aggressively creating a replica of a file whenever and wherever it is accessed.This paper presents the design, implementation, and evaluation of the Pangaea file system. Pangaea offers efficient, randomized algorithms to manage highly dynamic and potentially large groups of file replicas. It applies optimistic consistency semantics to replica contents, but it also offers stronger guarantees when required by the users. The evaluation demonstrates that Pangaea outperforms existing distributed file systems in large heterogeneous environments, typical of the Internet and of large corporate intranets.

Internet users increasingly rely on publicly available data for everything from software installation to investment decisions. Unfortunately, the vast majority of public content on the Internet comes with no integrity or authenticity guarantees. This paper presents the self-certifying read-only file system, a content distribution system providing secure, scalable access to public, read-only data.The read-only file system makes the security of published content independent from that of the distribution infrastructure. In a secure area (perhaps off-line), a publisher creates a digitally signed database out of a file system's contents. The publisher then replicates the database on untrusted content-distribution servers, allowing for high availability.The read-only file system avoids performing any cryptographic operations on servers and keeps the overhead of cryptography low on clients, allowing servers to scale to a large number of clients. Measurements of an implementation show that an individual server running on a 550-Mhz Pentium III with FreeBSD can support 1,012 connections per second and 300 concurrent clients compiling a large software package.

This paper presents the Modify-on-Access (Mona) file system that provides extensibility through transformations applied to streams of data. Mona overcomes two limitations of prior extensible file systems. First, the Mona file system offers two levels of extensions (kernel and user) that share a common interface. It allows performance-critical operations to execute with modest overhead in the kernel and untrusted or more complex operations to safely execute in user space. Second, Mona enables fine-grained extensions which allow an application to customize the file system at runtime. This paper discusses the implementation of the Mona file system. Our implementation adds modest overhead of 0-3 ° (0.01-0.21 µs) to file system operations. This overhead has even less effect on net system performance for several benchmarks. Moreover, this paper describes applications that achieve 4-5 times speedup using custom transformations. This paper also describes several transformations that increase functionality. Among these are the ftp transformation that allows a user to browse a remote file as though it were local and the command transformation which invokes an arbitrary executable (even a shell script) on a data stream.

This paper presents a recovery protocol for block I/O operations in Slice, a storage system architecture for high-speed LANs incorporating network-attached block storage. The goal of the Slice architecture is to provide a network file service with scalable bandwidth and capacity while preserving compatibility with off-the-shelf clients and file server appliances. The Slice prototype virtualizes the Network File System (NFS) protocol by interposing a request switching filter at the client's interface to the network storage system. The distributed Slice architecture separates functions typically combined in central file servers, introducing new challenges for failure atomicity. This paper presents a protocol for atomic file operations and recovery in the Slice architecture, and related support for reliable file storage using mirrored striping. Experimental results from the Slice prototype show that the protocol has low cost in the common case, allowing the system to deliver client file access bandwidths approaching gigabit-per-second network speeds.

Copy-On-Write (COW) is a powerful technique for data protection in file systems. Unfortunately, it introduces a recursively updating problem, which leads to a side effect of write amplification. Studying the behaviors of write amplification is important for designing, choosing and optimizing the next generation file systems. However, there are many difficulties for evaluation due to the complexity of file systems. To solve this problem, we proposed a typical COW file system model based on BTRFS, verified its correctness through carefully designed experiments. By analyzing this model, we found that write amplification is greatly affected by the distributions of files being accessed, which varies from 1.1x to 4.2x. We further found that write amplification is also affected by the number of files being accessed, the number of files contained in a file system, and as well as the space utilization of file system trees.

Mobile devices, such as smart phones, tablets, and netbooks, are now becoming increasingly popular. Effective access to remote files on servers in the network should be granted to the user. Today’s common distributed file systems, such as OpenAFS, Coda, and others, are not suitable for use on mobile devices. The user is forced either to access a particular server or at least to write to a server containing a master write replica. The path to the data is not chosen by the file system. So, the data transmission cannot reflect the user’s actual position. Wepropose a new file system supporting a multi-master write replica and routing the data requests

Widely available distributed file systems for big data processing are implemented as user-level services since the existing file systems, which are implemented in the operating system kernel, cannot satisfy their requirements. They usually employ file systems in the kernel to persistently save their data in their local systems; thus, the kernel is always interposed for their access the storage devices. Now, next generation non-volatile memory technologies are emerging as byte addressable memory devices that can be used as high performance storage, for which the interposition of the kernel is the source of overhead. This paper proposes the adaption of memory storage to user-level file system services and the convergence of such services and memory storage. User-level file system services are connected to memory storage through the library implementation of a file system, and a library file system can directly interact with memory storage through the memory interface by mapping memory storage onto a user process address space. We implemented a library file system on Linux. The experiment results show that the the implemented library file system outperforms the existing file system in the kernel and performs 1.9x and 6.5x faster for reading and writing, respectively, for typical cases.

In this paper, we design an augmented reality based file transfer system called ShareAR. The ShareAR system only needs a single-finger action that drags the file icon to the target face on the screen of a mobile device. The dragged file can be transmitted to the target receiver who gets the file immediately as her/his mobile device is on-line or receives the file later after connecting to the Internet. Through ShareAR, users do not need to know the target account in advance. In addition, users do not need to input account information by themselves. Furthermore, users can select a specific target among multiple candidates from the camera of a mobile device. ShareAR reveals an innovative user interface to transfer files between mobile devices. We have implemented an Android-based ShareAR system that outperforms existing schemes in experimental results.

In this paper, we propose the architecture of a wide area file service infrastructure, called I-Shadow. I-Shadow can provide both short delay file access and dependable file management for mobile users by using a set of active rules. We also show that average file access time of I-Shadow is shorter than that of cache based Coda distributed file system through a simulation study.

A storage system constructed by a wide-area distributed file system of open source software has been requested to ensure the certain existence of the non-falsification data by a trusted third party. We developed an integrity verification application using timestamp mechanism for Gfarm which is a wide-area distributed file system of open source software made in Japan. However, the application remained low performance. This paper explains an improvement method of the application and reports its performance in a basic evaluation.

Cloud-based object storage is provided as a cost-efficient, scalable, and durable service for accessing and storing objects through web technologies. With years of development and successful deployment, it has been widely adopted by individuals and organizations. Besides its advantages, there are several major concerns, such as, manageability, operation performance from a user perspective, convenience of access, and vendor lock-in. In this project, we have developed a File System as a Service (FSaaS) to address the aforementioned concerns. The FSaaS design is centred around separating file operations into groups and treating each operation group differently. We deal with the file system structures and attributes of objects in FSaaS, and leave the back-end storage as flat, and we provide a set of connector services that support various types of cloud storage for asynchronous operation mode. This separation of meta-data and use of connector services allow fast searching, transparent access, authentication simplification, concurrent operation, and load-balancing. The evaluation demonstrates that FSaaS can significantly improve user experience, boost operation performance, and reduce object operational delay. The scalability and flexibility of the FSaaS are also demonstrated via asynchronous operation mode.

File names are one of the earliest computing abstractions, a string of characters to uniquely identify a file for the system, and to help users remember the contents when they look for it later. They are also a rich source of semantic metadata about files. However, this metadata is unstructured and opaque to the rest of the system. As a result, metadata in file names is often error-prone, and hard to search for. File names can and should be more meaningful and reliable, while simplifying application design and encouraging users and applications to provide more metadata for search. We describe a POSIX compliant prototype file system, TrueNames, which demonstrates an alternate approach to naming and metadata, called metadata aware naming. TrueNames separates the task of uniquely identifying a file from the task of helping the user remember its contents. It captures metadata in a structured format for later indexing, and uses it to generate file names which are correct, regenerable, and disambiguatable by design. TrueNames simplifies application design by providing a consistent interface for metadata aware naming, incurs a low overhead of approximately 15[%] under realistic workloads, and can simplify a wide variety of data management tasks for both applications and users.

In Web applications, it is often needed to upload a file to the server. With current file upload methods, it is difficult to deal with large file uploaded and user experience is also bad. This paper introduces the principles and methods of files upload in the IIS environment and Java EE environment in detail. The FileList interface, Blob interface, File interface and FileReader interface in HTML5 on file operations are discussed in detail. A method of files upload using the interfaces in HTML5 on file operations is presented. This method applied to implement files upload has a better user experience.

In this paper, we investigate the benefits of adding autonomic capabilities inside the operating system. We have developed and implemented a solution that focuses on three use cases (continuous file permission compliance, dynamic disk cleanup, and accidental removal protection) for the file system, and encapsulates all the respective file system monitoring, troubleshooting and error remedial operations in a Linux kernel module. The main benefits of this approach are the capability to detect issues instantly when they occur, and fix these issues transparently, with the invoking applications being unaware of their occurence. These capabilities are not present in external agent architectures, including contemporary configuration management systems, like Puppet, Chef, or CFEngine. We have built a prototype and evaluated the performance of the most resource intensive use case, dynamic disk cleanup, using the FileBench file system benchmarking tool.

Distributed System is a group of autonomous computers that are networked together and appears to its users as single coherent system. Distributed File System (DFS) is a core component of a distributed system (DS) and it is used for storing and sharing data among authorized users of the DS. File sharing semantics are used by the file systems for sharing the data in a consistent manner. Most of the DFSs use Session Semantics for file sharing purpose. The main disadvantage of Session Semantics is that concurrent client processes may not be able to read recent and consistent data. In this paper, we propose a speculation-based novel scheme for the BlobSeer DFS which permits the updated contents of a file can be revealed to other concurrent clients immediately without waiting for the closure of the session by the client which updates the file. So, clients can read the most recently modified and consistent data from the BlobSeer DFS.

The emerging Storage Class Memory, which offers characteristics of byte-addressability, persistence, and low power consumption, will be expected to replace memory/storages. A new file system is required in this environment. In the design of file systems, data consistency is one of the most important issues that should be taken into account. To do this, most file systems exploit journaling or shadow paging for the consistency. Shadow paging employs copy-on-write for the consistency. However, it incurs many copy overheads. In order to relieve these problems, BPFS proposed a short-circuit shadow paging. But, in our experiments, we showed that it incurs many copy-on-write blocks as ever. In this paper, we propose a last block logging mechanism for improving the performance and the lifetime of SCM-based file system, by reducing copy-on-write blocks considerably. Our approach is to store the only changed contents to the available space of the last block, instead of performing copy-on-write on the entire block. Also, our approach updates the address of the last block and maintains the information on the logged data in order to ensure the data consistency. SQLite benchmark shows that the proposed mechanism reduces the overall elapsed time by 14% and the written data amount up to 72%, compared to the mechanism of BPFS.

On a Linux server, the way in which the hard disk is organized—and in which the file systems are created on that hard disk—is essential. There are many choices to be made, and there is no single solution that fits all needs. In this chapter, you’ll first assess if you have to work with partitions, or whether you’re better off working with logical volumes. You’ll also examine how partitions and volume behave differently on a master boot record (MBR) and on a globally unique identifier (GUID) partition table. Next, you’ll discover how to create partitions and logical volumes. Once the storage volume has been created, you have to put a file system on it. In this chapter, you’ll learn which file system best fits your needs and how to manage specific file-system features.

MemFS is a fully-symmetrical, in-memory distributed runtime file system. Its design is based on uniformly distributing file stripes across the storage nodes belonging to an application by means of a distributed hash function, purposefully sacrificing data locality for balancing both network traffic and memory consumption. This way, reading and writing files can benefit from full network bisection bandwidth, while data distribution is balanced across the storage servers.

You can use the BlackBerry 10 device’s file system in order to store your application’s data and share files with other apps running on the device. This appendix gives you an overview of your application’s home directory’s structure and the corresponding directory permissions.

With several new virtualization technologies, a virtual machine has gradually achieved higher performance. However, I/O-intensive workloads still suffer from performance degradation due to CPU mode switching and duplicated I/O stacks. In this paper, we propose a framework for improving file I/O performance in a virtualized environment, which consists of a paravirtualized file system, a shared queue, and an I/O-dedicated thread. The key idea is to make file I/O requests handled without mode switching and to bypass a guest I/O stack. We implemented a prototype and measured its performance. The results show that our framework gives 1.2-1.6 times better performance than virtio, and most of vmexits are eliminated.

Existing cryptographic file systems for Unix do not take into account that sensitive data must often be shared with other users, but still kept secret. By design, the only one who has access to the secret data is the person who encrypted it and therefore knows the encryption key or password. This paper presents a kernel driver for a new encrypted file system, called Fairly Secure File System (FSFS), which provides mechanisms for user management and access control for encrypted files. The driver has been specifically designed with multi user systems in mind. FSFS also tries to prevent unintentional transfer of sensitive data to unencrypted file systems, where it would be stored in plaintext.

Previous studies have shown that disk I/O times are one of the major performance bottlenecks of Internet servers such as proxy cache servers. Most conventional file systems do not work well for such systems because of their very high overheads. Although Special-purpose operating systems may achieve high performance, it is very difficult and expensive to design and maintain. They also have very poor portability. In this paper we propose to built user-space, customized file systems for Internet servers so as to achieve high-performance, low-implementation-cost and good portability at the same time. To provide an example of such systems, we presented a novel scheme called WPSFS that can drastically improve I/O performance of proxy servers and other applications. WPSFS is an application-level software component of a proxy server which manages data on a raw disk or disk partition. Since the entire system runs in the user space, it is easy and inexpensive to implement. It also has good portability and maintainability. With efficient in-memory meta-data data structures and a novel file system called Page-structured file system(PFS) , WPSFS achieves 9-20 times better I/O performance than the state-of-the-art SQUID server running on a Unix Fast File System, and 4-10 times better than the improved SQUIDML.

Today's file systems are limited in speed and reliability by memory's vulnerability to operating system crashes. Because memory is viewed as unsafe, systems periodically write modified file data back to disk. These extra disk writes lower system performance and the delay period before data is safe lowers reliability. The goal of the Rio (RAM I/O) file cache is to make ordinary main memory safe for persistent storage by enabling memory to survive operating system crashes. Reliable main memory enables the Rio file cache to be as reliable as a write-through file cache, where every write is safe instantly, and as fast as a pure write-back file cache, with no reliability-induced writes to disk. This paper describes the systematic, quantitative process we used to design and verify the Rio file cache on Intel PCs running FreeBSD and the reliability and performance of the resulting system.

Summary Parallel file systems commonly distribute a file across multiple file servers with a fixed-size stripe, thereby allowing data access through multiple file servers. This default data layout works well in traditional homogeneous storage systems, but when solid state disks (SSDs) are conducted into a storage system, the data layout of hybrid parallel file systems has a chance to obtain better I/O performance. In this study, we propose a variable-sized stripe level data layout strategy for hybrid parallel file systems (SLDP). SLDP divides the file into several regions according to the data access pattern and then finds the optimal configurations for each region among the solid state disk file server nodes and mechanical hard disk drive file server nodes. It uses variable stripe sizes to reorganize the data layout of file systems. Furthermore, it considers SSD space limitation, the main idea is to distribute key regions of the file to hybrid parallel file systems based on the optimal stripe configuration, which can significantly improve the system I/O throughput performance. The remaining parts of a file are then distributed according to the SSD free space threshold, which can leverage the SSD servers as much as possible. To achieve this, SLDP divides a large file into many fine-grained regions and adjusts the data layout method for each region according to the access patter. Experimental results show that the SLDP is feasible and can improve system performance. Copyright © 2016 John Wiley & Sons, Ltd.

File systems provide an interface for applications to obtain exclusive access to files, in which a process holds privileges to a file that cannot be preempted and restrict the capabilities of other processes. Local file systems do this by maintaining information about the privileges of current file sessions, and checking subsequent sessions for compatibility. Implementing exclusive access in this manner for distributed file systems degrades performance by requiring every new file session to be registered with a lock server that maintains global session state. We present two techniques for improving the performance of session management in the distributed environment. We introduce a distributed lock for managing file access, called a i>semi-preemptible lock, that allows clients to cache privileges. Under a semi-preemptible lock, a file system creates new sessions without messages to the lock manager. This improves performance by exploiting locality – the affinity of files to clients. We also present data structures and algorithms for the i>dynamic evaluation of locks that allow a distributed file system to efficiently manage arbitrarily complex locking. In this case, complex means that an object can be locked in a large number of unique modes. The combination of these techniques results in a distributed locking scheme that supports fine-grained concurrency control with low memory and message overhead and with the assurance that their locking system is correct and avoids unnecessary deadlocks.

Cloud Computing offers great benefits such as reduced IT costs and an improved business agility. Nevertheless, enterprises are still hesitant to put their sensitive data in the cloud as they notably fear privacy issues (e.g., violation of country-based regulations regarding the storage location of a sensitive data). In this context, this paper presents the demonstration of a privacy control technology that allows to protect sensitive files stored, processed, and moved in an IaaS cloud. In our approach, the privacy control is performed within the file system of the Virtual Machines (VM) and allows to control the access done by any application to each sensitive file. It notably covers business applications (e.g., provided by the cloud user) and system applications such as FTP (e.g., to prevent the transfer of a sensitive file in a not authorized country). Moreover, our technology allows to generate tamper-proof traces for any action performed on a sensitive file. In the demonstration, we then also show how the cloud user has a full view of the usage of his sensitive files (e.g., number of copies, storage locations, performed actions). Finally, the demonstration shows these different capabilities through a scenario of file access and cross-country transfer in a multi-platform cloud environment.

After decryption, the data in mobile storage is lack of the protection from encryption. To solve this problem, our team proposed an aprotection scheme for classified documents, which is based on kernel level file filtering system, implements a set of data protection system for mobile storage medium. First, through the transparent encryption technology, ensure that unauthorized visitors cannot access classified documents; Then through the file redirection technology, make sure that the decrypted data is under the comprehensive protection when authorized users are in the normal using process; Finally, clear the temporary file on the disk and the data trace in the memory, ensure that no using trace left on the computer. Experimental results show that this project has realized comprehensive security protection for classified documents, and achieve the goal that classified devices can be used on unclassified computer safely.

Sharing files over the world with higher access throughput and with lower storage cost is a growing demand for the applications that use large files. However, the existing file sharing systems do not realize these two conflicted requests and no research has been found. This paper clarifies the requirements of a global large file sharing system and defines the design goal consisting of three users perspectives: fast retrieving, user defined file availability, and owner-based file management, and one system operators perspective: flexibility in bytes placement. Content Espresso satisfies this goal by approaching with four techniques: three sections model, distributed chunk storage, forward error correction, and UDP retrieving. Content Espresso delivers large files to a client utilizing as much bandwidth as the client access link even servers are located far away from the client.

The processing of massive small files is a challenge in the design of distributed file systems. Currently, the combined-block-storage approach is prevalent. However, the approach employs traditional file systems like ExtFS and may cause inefficiency for random access to small files. This paper focuses on optimizing the performance of data servers in accessing massive small files. We present a Flat Lightweight File System (iFlatLFS) to manage small files, which is based on a simple metadata scheme and a flat storage architecture. iFlatLFS aims to substitute the traditional file system on data servers that are mainly used to store small files, and it can greatly simplify the original data access procedure. The new metadata proposed in this paper occupies only a fraction of the original metadata size based on traditional file systems. We have implemented iFlatLFS in CentOS 5.5 and integrated it into an open source Distributed File System (DFS), called Taobao FileSystem (TFS), which is developed by a top B2C service provider, Alibaba, in China and is managing over 28.6 billion small photos. We have conducted extensive experiments to verify the performance of iFlatLFS. The results show that when the file size ranges from 1KB to 64KB, iFlatLFS is faster than Ext4 by 48% and 54% on average for random read and write in the DFS environment, respectively. Moreover, after iFlatLFS is integrated into TFS, iFlatLFS-based TFS is faster than the existing Ext4-based TFS by 45% and 49% on average for random read access and hybrid access (the mix of read and write accesses), respectively.

For many years now, I/O read time has been recognized as the primary bottleneck for parallel visualization and analysis of large-scale data. In this paper, we introduce a model that can estimate the read time for a file stored in a parallel filesystem when given the file access pattern. Read times ultimately depend on how the file is stored and the access pattern used to read the file. The file access pattern will be dictated by the type of parallel decomposition used. We employ spatio-temporal parallelism, which combines both spatial and temporal parallelism, to provide greater flexibility to possible file access patterns. Using our model, we were able to configure the spatio-temporal parallelism to design optimized read access patterns that resulted in a speedup factor of approximately 400 over traditional file access patterns.