Search

Tamper-evident logging is paramount for forensic audits and accountability subsystems. It is based on a forward integrity model: upon intrusion, the attacker is not able to counterfeit the logging data generated before controlling the system. There are local and distributed solutions to this problem. Distributed solutions are suitable for common scenarios, albeit not appropriate for autonomous and loosely connected systems. Moreover, they can be complex and introduce new security issues. Traditional local tamper-evident logging systems use cryptographic ratchets. In previous works, we presented SealFS (from now on, SealFSv1), a system that follows a radically different approach for local tamper-evident logging based on keystream storage. In this paper, we present a new version, SealFSv2, which combines ratcheting and storage-based log anti-tamper protection. This new approach is flexible and enables the user to decide between complete theoretical security (like in SealFSv1) and partial linear degradation (like in a classical ratchet scheme), exchanging storage for computation with user-defined parameters to balance security and resource usage. We also describe an implementation of this scheme. This implementation, which showcases our approach, is an optimized evolution of the original sealfs Linux kernel module. It implements a stackable file system that enables transparent tamper-evident logging to all user space applications and provides instant deployability. Last, we present a complete performance evaluation of our current implementation and a fair performance comparison of the two opposite approaches for local tamper-evident logging (i.e., storage-based vs. ratcheting). This comparison suggests that, on current systems and general-purpose hardware, the storage-based approach and hybrid schemes perform better than the traditional ratchet approach. [ABSTRACT FROM AUTHOR]

Securing multimedia data on disk drives is a major concern because of their rapidly increasing volumes over time, as well as the prevalence of security and privacy problems. Existing cryptographic schemes have high computational costs and slow response speeds. They also suffer from limited flexibility and usability from the user side, owing to continuous routine interactions. Dynamic encryption file systems can mitigate the negative effects of conventional encryption applications by automatically handling all encryption operations with minimal user input and a higher security level. However, most state-of-the-art cryptographic file systems do not provide the desired performance because their architectural design does not consider the unique features of multimedia data or the vulnerabilities related to key management and multi-user file sharing. The recent move towards multi-core processor architecture has created an effective solution for reducing the computational cost and maximizing the performance. In this paper, we developed a parallel FUSE-based encryption file system called ParallelFS for storing multimedia files on a disk. The developed file system exploits the parallelism of multi-core processors and implements a hybrid encryption method for symmetric and asymmetric ciphers. Usability is significantly enhanced by performing encryption, decryption, and key management in a manner that is fully dynamic and transparent to users. Experiments show that the developed ParallelFS improves the reading and writing performances of multimedia files by approximately 35% and 22%, respectively, over the schemes using normal sequential encryption processing. [ABSTRACT FROM AUTHOR]

Internet and IoT Applications generate large amounts of data that require efficient storage and processing. Emerging Compute Express Link (CXL) and Non-Volatile Memories (NVM) bring new opportunities for in-memory computing by reducing the latency of data access and processing. Many in-memory file systems based on the Hybrid DRAM/NVM are designed for high performance. However, achieving high performance under Non-Uniform Memory Access (NUMA) multiprocessor systems has significant challenges. In particular, the performance of file requests on NUMA systems varies over a disturbingly wide range, depending on the affinity of threads to file data. Moreover, memory controllers and interconnect links congestion bring excessive latency and performance loss on file accesses. Therefore, both the placement of file and thread and load balance are critical for data-intensive applications on NUMA systems. In this paper, we optimize the performance of multiple threads requesting in-memory files on NUMA systems by considering both memory congestion and data locality. First, we present the system model and formulate the problem as latency minimization on NUMA nodes. Then, we present a two-layer design to optimize the performance by properly migrating threads and dynamically adjusting the file distribution. Further, based on the design, we implement a functional NUMA-aware in-memory file system, Hydrafs-RFCT, in the Linux kernel. Experimental results show that the Hydrafs-RFCT optimizes the performance of multi-thread applications on NUMA systems. The average aggravated performance of Hydrafs-RFCT is 100.14 %, 112.7 %, 39.4 %, and 6.4 % higher than that of Ext4-DAX, PMFS, SIMFS, and Hydrafs, respectively. [ABSTRACT FROM AUTHOR]

Existing nonvolatile memory (NVM)-based file systems can fully leverage the characteristics of NVM to obtain better performance than traditional disk-based file systems. It has the potential capacity to efficiently manage metadata and perform fast metadata operations. However, most NVM-based file systems mainly focus on managing file metadata (inode), while pay little attention to directory metadata (dentry), which also has a noticeable impact on the file system performance. Besides, the traditional journaling technique that guarantees metadata consistency may not yield satisfactory performance on NVM-based file systems. To solve these problems, in this article we propose a fast and low overhead metadata operation mechanism, called FLOMO. It first adopts a novel slotted-paging structure in NVM to reorganize dentry for efficiently performing dentry operations, and utilizes the red–black tree in DRAM to accelerate dentry lookup and the search process of dentry deletion. Moreover, FLOMO presents a selective journaling scheme for metadata updates, which partially logs the changes related to dentry in the proposed slotted page, thereby, mitigating the redundant journaling overhead. To verify FLOMO, we implement it in a typical NVM-based file system, the persistent memory file system (PMFS). Experimental results show that FLOMO accelerates the metadata operations in PMFS by 34.4% $\sim 59$ %, and notably reduces the journaling overhead for metadata, shortening the latency by 59% on average. For real-world applications, FLOMO has higher throughput compared with PMFS, PMFS without journal, and NOVA, achieving up to $2.1\times $ , $1.1\times $ , and $1.3\times $ performance improvement, respectively. [ABSTRACT FROM AUTHOR]

In file systems, a single write system call can make multiple modifications to data and metadata, but such changes are not flushed in an atomic way. To retain the consistency of file systems, conventional approaches guarantee crash consistency in exchange for sacrificing system performance. To mitigate the performance penalty, non-volatile memory (NVM) technologies are believed to be a good candidate for this purpose owing to their low latency and byte-addressibility. However, none of the prior proposals that exploit NVM provide both scalability and strict ordering of modifications. In this article, we propose montage, a crash consistency framework for file systems that consists of two parts. First, montage splits NVM space into multiple staging areas and synchronizes the flushing of modifications these to the storage device. Second, montage uses the pipelined architecture to speed up data flushing to storage. We apply montage to two journaling file systems (ext4 and JFS) and evaluate them on a multicore server with high-performance storage. The evaluation results demonstrate that our design exhibits better performance by a wide margin than recent NVM-based journaling file systems. [ABSTRACT FROM AUTHOR]

The mismatch between logical and physical I/O granularity inhibits the deployment of embedded file systems. Most existing embedded file systems manage logical space with a small unit, which is no longer the case of the flash operation granularity. Manually enlarging the logical I/O granularity of file systems requires enormous transplanting efforts. Moreover, large logical pages signify the write amplification problem, which turns to severe space consumption and performance collapse. This article designs a novel storage middleware, NV-middle, for legacy-embedded file systems with large-capacity flash memories. Legacy-embedded storage schemes can be smoothly transplanted into new platforms with different hardware read/write granularity. Moreover, the legacy optimization schemes can be maximally reserved, without inducing write amplification problems. We implement NV-middle with the state-of-the-art embedded file system, YAFFS2. Comprehensive evaluations show that NV-middle can achieve times of performance improvement over manually transplanted YAFFS2 with various workloads. [ABSTRACT FROM AUTHOR]

The emerging non-volatile memory ( NVM) is byte-addressable, which has the characteristics of low latency similar to memory and the nonvolatile property of storage. Limited by the maturity of hardware and software technology, NVM was firstly used in storage. This paper discussed a series of problems and management challenges of NVM for storage. Then, it summarized the main features of the existing typical NVM file systems. These features mainly focused on reducing consistency overhead, reducing the software stack cost, the integrated management of memory and storage, distributed file system, NVM file system security, fault tolerance, space management and so on. Finally, this paper prospected several research directions of NVM file system, including scalability, fusion of virtual memory and file system, and distributed file system. [ABSTRACT FROM AUTHOR]

We propose a new I/O architecture for NAND flash-based SSDs, called application-managed flash (AMF) and present two case studies to show its usefulness. In a typical SSD controller, an intermediate software layer, called the flash translation layer (FTL), is employed between NAND flash chips and a host interface. The main responsibility of an FTL is to provide interoperability with conventional HDDs, but this interoperability comes at the cost of extra hardware resources and degraded I/O performance. The proposed AMF refactors the flash storage architecture so that an SSD controller exposes append-only segments, which do not permit overwriting. This refactoring dramatically improves performance of applications and reduces hardware costs by allowing applications to directly manage flash storage with minimal supports from the SSD controller. In order to understand the benefits of AMF, we study two popular applications: a log-structured file system (F2FS) and a key-value store (RocksDB). Our experiments show that the DRAM in the flash controller is reduced by 128X and the performances of the file system and the key-value store improve by 80 and 54 percent, respectively, over conventional SSDs. [ABSTRACT FROM AUTHOR]

In order to protect the data during system crash, traditional DRAM–DISK architecture file systems (e.g., EXT4) need to synchronize the dirty metadata and data from the memory to disk. At the same time, the disk synchronization may break the consistency of file system upon a crash, so traditional file systems use some mechanisms to guarantee the file system consistency when the dirty metadata and data is synchronized onto persistent storage devices (e.g., HDD and SSD). Journaling is a consistency mechanism widely used by file systems. We observe that the overhead of periodic disk synchronization and journaling is high. Emerging non-volatile memories (NVMs) can be potentially utilized to reduce these overheads. In this paper, we present hybrid architecture for storage file system (HasFS), a file system designed for the DRAM–NVM–DISK architecture. HasFS extends the main memory with NVM and considers NVM as a persistent page cache to eliminate the periodic disk synchronization overhead of dirty data. Then we design an efficient consistency mechanism based on the hybrid memory architecture to provide strong (both metadata and data) consistency guarantee with low overhead. The evaluation demonstrates that HasFS outperforms mainstream DRAM–DISK file systems for many workloads. For instance, HasFS has between 1.6X to 46.6X performance improvement over other tested file systems in random write workload. In particular, HasFS outperforms EXT4 without journal in some cases even though HasFS provides metadata and data consistency guarantees (similar to EXT4 with journal data mode). [ABSTRACT FROM AUTHOR]

Anti-forensic techniques aim to prevent, hinder or corrupt the forensic process of evidence acquisition, its analysis, and/or its admissibility. File systems are at the spotlight of almost every forensic investigation. The Linux B-tree file system (Btrfs) offers a paradigm shift in file system design by providing simple administration, end-to-end data integrity, and immense scalability without loss of performance. However, the potential of Btrfs for forensics examination and its resistance to anti-forensic activities was not investigated before. This paper covers this gap by analysing the forensics value of Btrfs and its robustness against anti-forensics activities. The experimental results suggest that Btrfs offers strong hurdles to many anti-forensic attacks. These include making it difficult to securely wipe files, disallowing hiding data in reserved locations of the file system data structures, and so on. Based on our findings, even a corrupt Btrfs volume could contain remnants of deletion of small files, hidden data in reserved locations and magic string forgery. Furthermore, forensic tools meant for Btrfs investigation must be augmented to support automated forensic analysis of possible hidden data in boot sector, file slack, volume slack and mount-point directories, MAC-DTS forgery, and sparse files. [ABSTRACT FROM AUTHOR]

Buffer caching is an effective approach to improve the system performance and extend the lifetime of SSDs. However, the frequent synchronization operations in most real-world applications limit such advantages. This paper proposes to adopt emerging non-volatile main memories (NVMMs) to relieve the above problems while achieving both efficient and consistent cache management. To this end, an adaptive fine-grained cache (AFCM) scheme is proposed, which is motivated by our observation that the file data in many synchronized pages is partially updated for a wide range of workloads, implying that fine-grained cache management can save the NVMM cache space wasted by the clean parts. To reduce the cache index overhead introduced by fine-grained cache management, AFCM employs a Hybrid Cache based on DRAM and NVMM, with which the normal read and write operations are served without performance penalty. We also propose the Transactional Copy-on-Write mechanism to guarantee the crash consistency of both NVMM cache space and file system image. Our experimental results show that AFCM provides up to 84 percent performance improvement and 63 percent SSD write reduction on average compared to the conventional coarse-grained cache management scheme. [ABSTRACT FROM AUTHOR]

Owing to the increasing Internet population, there has been an explosion in the amount of digital data generated and also an increase in data complexity. This trend is called big data paradigm. As the Internet of Things (IoT) takes center stage, the growth of data will continue to increase. Therefore, the demand for mass storage devices that have high access speed is increasing. Industry has been paying attention to flash memories that can process large amounts of data at high speed. It will be a good alternative for storing and processing ever-increasing amounts of data because of low power consumption, high shock resistance, portability and fast access speed. However, the write speed is about 10–20 times slower than the read speed in flash memory. In addition, write operations are not allowed to be performed with in-place updates. Garbage collection mechanism is proposed in order to solve the problem incurred by the not-in-place update property of write operations. However, garbage collection mechanism unavoidably causes overhead of additional internal operations, which leads to performance degradation. In this paper, to prevent performance degradation caused by garbage collection, we propose a request-size-aware flash translation layer (RSaFTL) and a hierarchical request-size-aware flash translation layer (HiRSaFTL). They are designed based on page-level address translation. In RSaFTL and HiRSaFTL, page-sized data with high temporal locality cluster into a special area called active blocks by exploiting the property of realistic traces. As a result of the experiments, RSaFTL and HiRSaFTL reduce the number of pages migrated during garbage collections by up to 17.9% and 21.3%, respectively, compared with pure page-level flash transition layer. [ABSTRACT FROM AUTHOR]

With the remarkable increase in computer crimes – particularly Internet related crimes – digital forensics become an urgent and a timely issue to study. Normally, digital forensics investigation aims to preserve any evidence in its most original form by identifying, collecting, and validating the digital information for the purpose of reconstructing past events. Most digital evidence is stored within the computer's file system. This research investigates and evaluates the applicability of several machine learning techniques in identifying incriminating evidence by tracing historical file system activities in order to determine how these files can be manipulated by different application programs. A dataset defined by a matrix/vector of features related to file system activity during a specific period of time has been collected. Such dataset has been used to train several machine learning techniques. Overall, the considered machine learning techniques show good results when they have been evaluated using a testing dataset containing unseen evidence. However, all algorithms encountered an essential obstacle that could be the main reason as why the experimental results were less than expectation that is the overlaps among the file system activities. [ABSTRACT FROM AUTHOR]

Modern file systems employ journaling techniques to guarantee data consistency in case of unexpected system crashes or power failures. However, journaling file systems usually suffer from performance decrease due to the extra journal writes. Moreover, the emerging non-volatile memory technologies (NVMs) have the potential capability to reduce the journaling overhead by being deployed as the journaling storage devices. However, traditional journaling techniques, which are designed for hard disks, fail to perform efficiently in NVMs. In order to address this problem, we propose an NVM-based journaling scheme, called NJS. The basic idea behind NJS is to reduce the journaling overhead of traditional file systems while fully exploiting the byte-accessibility characteristic of NVM, and alleviating the slow write and endurance limitation of NVM. Our NJS consists of four major contributions: (1) In order to decrease the amount of journal writes, NJS only needs to write the file system metadata and over-write data to NVM as write-ahead logging, thus alleviating the slow write and endurance limitation of NVM. (2) NJS adopts a wear aware strategy for NVM journal block allocation in which each block can be evenly worn out, thus further extending the lifetime of NVM. (3) We propose a novel journaling update scheme in which journal data blocks can be updated in the byte-granularity based on the difference of the old and new versions of journal blocks, thus fully exploiting the unique byte-accessibility characteristic of NVM. (4) NJS includes a garbage collection mechanism that absorbs the redundant journal updates, and actively delays the checkpointing to the file system. Evaluation results show the efficiency and efficacy of NJS. For example, compared with Ext4 with a ramdisk-based journaling device, the throughput improvement of Ext4 with our NJS is up to 131.4 percent. [ABSTRACT FROM AUTHOR]

NAND flash memory has been widely used in consumer electronics, such as tablet personal computers and smart phones. However, unlike traditional hard disk, a garbage collection is required to reclaim memory space during data updates. A garbage collection includes a series of extra read, write and erase operations. Both write and erase operations are time consuming process, which affect the effectiveness and efficiency of the NAND flash memory system. Moreover, flash memory blocks are challenged by the limitation of the erase count. Thus, considerable efforts have been paid to reduce the garbage collection overhead and improve wear leveling. In this paper, an efficient and non-time-sensitive file-aware garbage collection algorithm, called FaGC+, is proposed. The FaGC+ algorithm involves a novel update frequency calculation method and a novel cold-hot logical page categorization scheme. The experimental results demonstrate that the proposed algorithm outperforms existing garbage collection algorithms in terms of garbage collection overhead and time-sensitivity in wear leveling control. [ABSTRACT FROM AUTHOR]

The byte-addressable Non-Volatile Memory (NVM) offers fast, fine-grained access to persistent storage, and a large volume of recent researches are conducted on developing NVM-based in-memory file systems. However, existing approaches focus on low-overhead access to the memory and only guarantee the consistency between data and metadata. In this paper, we address the problem of maintaining consistency among continuous snapshots for NVM-based in-memory file systems. We propose an efficient versioning mechanism and implement it in Hybrid Memory Versioning File System (HMVFS), which achieves fault tolerance efficiently and has low impact on I/O performance. Our results show that HMVFS provides better performance on snapshotting and recovering compared with the traditional versioning file systems for many workloads. Specifically, HMVFS has lower snapshotting overhead than BTRFS and NILFS2, improving by a factor of 9.7 and 6.6, respectively. Furthermore, HMVFS imposes minor performance overhead compared with the state-of-the-art in-memory file systems like PMFS. [ABSTRACT FROM AUTHOR]

The Internet of Things (IoT) and cloud computing are two important technologies in our life. They are integrated together to support each other. However, with the rapid development of IoT, the disk-based storage systems in clouds fail to process and analyze data timely from IoT devices. In order to improve the storage capabilities of traditional disk-based storage systems, we present a light-weight log-based hybrid storage system, which comprises of the phase change memory (PCM), flash memory-based SSD and disks. These devices are merged as a single block device with a continuous linear-address space. We also design and implement a log-based hybrid file system called HFS for the block device. By combining the semantic characteristics of data with distinct performance characteristics of devices, HFS optimizes the file system layout and overcomes the shortcomings of traditional log-structured systems. We implement HFS in the Linux kernel and compare it with modern file systems such as Ext4 and F2FS. Evaluation results show the efficiency of the proposed light-weight log-based hybrid storage system. [ABSTRACT FROM AUTHOR]

Due to advantages in aerospace data storage, flash memory has become the next generation of satellite storage solutions after DRAM , SDRAM. Because of the storage characteristics of flash memory, it leads to noneffective management of data storage. Therefore, the on-board flash file system is facing a lot of problems to be studied. By analyzing the characteristics of the satellite storage, this paper provided the data management requirements in the satellite-borne environment. It analyzed the IOPS(input/output operations per second)metadata, throughput, and random addressing of Hash file systems using simulation experiments. It demonstrates that F2FS is superior to BTRFS, exFAT, NILFS. Based on the specific tests, this paper analyzed the impact of the flash internal parallelism on the file system. The result shows that F2FS is better suited for data management on flash-based on-board storage. It also put forward improvement suggestions for data storage in satellite-borne environment. It provides a foundation for the design and implementation of flash file system in the satellite-borne environment. [ABSTRACT FROM AUTHOR]

The ability of managing large-scale data in cloud storage system is an important part of scalability of cloud storage system. However, in the evaluation of scalability, super large capacity test environment is the most difficult part. To solve this problem, this paper proposed a scalability evaluation plan in horizontal expansion and vertical expansion, designed and imple­mented an evaluation tool -- TPFS. TPFS which ran in the data nodes of cloud storage system provide real space for data and specified space only for meta data, besides it provided thin provisioning in the level of file system, in order to evaluate the scalability of cloud storage system. The results show that when the real space is only 40 GB , TPFS file system can reach the scalability of 8 TB. [ABSTRACT FROM AUTHOR]

SUMMARY We propose a method for shared file cache function for cloned files used by virtual machines, called SCC. The file clone function copies the files faster than conventional (read and write) method. Moreover, the function reduces disk spaces. The function is used to deploy virtual machines in virtual desktop infrastructure because of fast copying a lot of virtual machine disk files. SCC uses the file cache of a shared file as a shared cache among cloned files. The cached data on the shared file are returned to application programs on accessing the shared file via cloned files. Therefore, SCC improves the I/O performance of the shared file due to avoiding disk accesses. In this paper, we implement SCC and evaluate the I/O performance. From the evaluation, we have found SCC improves I/O throughput about 38 times in the case of random read and shared cache hit. [ABSTRACT FROM AUTHOR]

Fast non-volatile memory (NVM) technologies (e.g., phase change memory, spin-transfer torque memory, and MRAM) provide high performance to legacy storage systems. These NVM technologies have attractive features, such as low latency and high throughput to satisfy application performance. Accordingly, fast storage devices based on fast NVM lead to a rapid increase in the demand for diverse computer systems and environments (e.g., cloud platforms, web servers, and database systems) where they are expected to be used as primary storage. Despite the promised benefits provided by fast storage devices, modern file systems do not take advantage of the storage’s full performance. In this article, we analyze and explore existing I/O strategies in read, write, journal I/O, and recovery paths between the file system and the storage device. The analysis shows that existing I/O strategies are an obstacle to get maximum performance of fast storage devices. To address this issue, we propose efficient I/O strategies that enable file systems to fully exploit the performance of fast storage devices. Our main idea is to transfer requests from discontiguous host memory buffers in the file systems to discontiguous storage segments in one I/O request to get maximize I/O performance. We implemented our scheme to read, write, journal I/O and recovery operations in the EXT4 file system and the JBD2 module. We demonstrate the implication of our idea in terms of application performance through well-known benchmarks. The experimental results show that our optimized file system achieves better performance than the existing file system, with improvements of up to 1.54 $\times$, 1.96$\times$ , and 2.28 $\times$ on ordered mode, data journaling mode, and recovery, respectively. [ABSTRACT FROM AUTHOR]

Primary storage dedup is difficult to be accomplished because of challenges to achieve low IO latency and high throughput while eliminating data redundancy effectively in the critical IO Path. In this paper, we design and implement the PDFS, a partially dedupped file system for primary workloads, which is built on a generalized framework using partial data lookup for efficient searching of redundant data in quickly chosen data subsets instead of the whole data. PDFS improves IO latency and throughput systematically by techniques including write path optimization, data dedup parallelization and write order preserving. Such design choices bring dedup to the masses for general primary workloads. Experimental results show that PDFS achieves 74-99 percent of the theoretical maximum dedup ratio with very small or even negative performance degradations compared with main stream file systems without dedup support. Discussions about varied configuring experiences of PDFS are also carried out. [ABSTRACT FROM PUBLISHER]

SUMMARY We propose a method of high-throughput file-level deduplication for primary file servers, called partial data background prefetch (PDBP). To achieve high throughput of deduplication, the method reduces the number of disk I/Os issued during deduplication process. Before running deduplication process, the proposed method prefetches a part of data of shred files referred by deduplicated files. After that, the method processes the files that are larger than a file-size threshold defined by administrators. In this paper, we evaluate a deduplication processing time by using a simulation model of PDBP. Consequently, we confirm that the processing time of PDBP is reduced by about 50% compared to a conventional file deduplication method when the threshold is set to 4 KB. [ABSTRACT FROM AUTHOR]

The emerging technologies of persistent memory, such as PCM, MRAM, provide opportunities for preserving files in memory. Traditional file system structures may need to be re-studied. Even though there are several file systems proposed for memory, most of them have limited performance without fully utilizing the hardware at the processor side. This paper presents a framework based on a new concept, “File Virtual Address Space”. A file system, Sustainable In-Memory File System (SIMFS), is designed and implemented, which fully utilizes the memory mapping hardware at the file access path. First, SIMFS embeds the address space of an open file into the process’ address space. Then, file accesses are handled by the memory mapping hardware. Several optimization approaches are also presented for the proposed SIMFS. Extensive experiments are conducted. The experimental results show that the throughput of SIMFS achieves significant performance improvement over the state-of-the-art in-memory file systems. [ABSTRACT FROM AUTHOR]

Recently, flash memory is widely used as a non-volatile storage for embedded applications such as smart phones, MP3 players, digital cameras and so on. The software layer called flash translation layer (FTL) becomes more important since it is a key factor in the overall flash memory system performance. Many researchers have proposed FTL algorithms for small block flash memory in which the size of a physical page of flash memory is equivalent to the size of a data sector of the file system. However, major flash vendors have now produced large block flash memory in which the size of a physical page is larger than the file system's data sector size. Since large block flash memory has new features, designing FTL algorithms specialized to large block flash memory is a challenging issue. In this paper, we provide an efficient FTL named LSTAFF* for large block flash memory. LSTAFF* is designed to achieve better performance by using characteristics of large block flash memory and to provide safety by abiding by restrictions of large block flash memory. Experimental results show that LSTAFF* outperforms existing algorithms on a large block flash memory. [ABSTRACT FROM AUTHOR]

Purpose – Research data management (RDM) comprises all processes, which ensure that research data are well-organized, documented, stored, backed up, accessible, and reusable. RDM systems form the technical framework. The purpose of this paper is to present the design and implementation of a RDM system for an interdisciplinary, collaborative, long-term research project with focus on Soil-Vegetation-Atmosphere data. Design/methodology/approach – The presented RDM system is based on a three-tier (client-server) architecture. This includes a file-based data storage, a database-based metadata storage, and a self-designed user-friendly web-interface. The system is designed in cooperation with the local computing centre, where it is also hosted. A self-designed interoperable, project-specific metadata schema ensures the accurate documentation of all data. Findings – A RDM system has to be designed and implemented according to requirements of the project participants. General challenges and problems of RDM should be considered. Thus, a close cooperation with the scientists obtains the acceptance and usage of the system. Originality/value – This paper provides evidence that the implementation of a RDM system in the provided and maintained infrastructure of a computing centre offers many advantages. Consequently, the designed system is independent of the project funding. In addition, access and re-use of all involved project data is ensured. A transferability of the presented approach to another interdisciplinary research project was already successful. Furthermore, the designed metadata schema can be expanded according to changing project requirements. [ABSTRACT FROM AUTHOR]

Lately, fast storage devices are rapidly increasing in social network services, cloud platforms, etc. Unfortunately, the traditional Linux I/O stack is designed to maximize performance on disk-based storage. Emerging byte-addressable and low-latency non-volatile memory technologies (e.g., phase-change memories, MRAMs, and the memristor) provide very different characteristics, so the disk-based I/O stack cannot lead to high performance. This paper presents a high performance I/O stack for the fast storage devices. Our scheme is to remove the concept of block and to simplify the whole I/O path and software stack, which results in only two layers that are the byte-capable interface and the byte-aware file system called BAFS. We aim to minimize I/O latency and maximize bandwidth by eliminating the unnecessary layers and supporting byte-addressable I/O without requiring changes to applications. We have implemented a prototype and evaluated its performance with multiple benchmarks. The experimental results show that our I/O stack achieves 6.2 times on average and up to 17.5 times performance gains compared to the existing Linux I/O stack. [ABSTRACT FROM AUTHOR]

Background: Successful endodontic therapy depends on many factor, one of the most important step in any root canal treatment is root canal preparation. In addition, respecting the original shape of the canal is of the same importance; otherwise, canal aberrations such as transportation will be created. Aim: The purpose of this study is to compare and evaluate Reciprocating WaveOne ,Reciproc and Rotary Oneshape Single File Instrumentation System On Cervical Dentin Thickness, Cross Sectional Area and Canal Transportation on First Mandibular Molar Using Cone Beam Computed Tomography. Materials and Methods: Sixty Mandibular First Molars extracted due to periodontal reason was collected from the Department of Oral and Maxillofacial. Teeth were prepared using one rotary and two reciprocating single file system. Teeth were divided into 3 groups 20 teeth in each group. Pre instrumentation and Post instrumentation scans was done and evaluated for three parameters Canal Transportation, Cervical Dentinal Thickness, Cross-sectional Area. Results were analysed statistically using ANOVA, Post-Hoc Tukey analysis. Results: The change in cross-sectional area after filing showed significant difference at 0mm, 1mm, 2mm and 7mm (p<0.001, p =0.006, 0.004 & <0.001 respectively). There was significant difference between wave one and oneshape; oneshape and reciproc at 0mm, 1mm, 2mm & 7mm (p-values for waveone and Oneshape <0.001, 0.022, 0.011 & <0.001 resp. and for oneshape and reciproc < 0.001, p= 0.011, p=0.008 & <0.001). On assessing the transportation of the three file system over a distance of 7 mm (starting from 0mm and then evaluation at 1mm, 2mm, 3mm, 5mm and 7mm), the results showed a significant difference among the file systems at various lengths (p= 0.014, 0.046, 0.004, 0.028, 0.005 & 0.029 respectively). Mean value of cervical dentinal removal is maximum at all the levels for oneshape and minimum for waveone showing the better quality of waveone and reciproc over oneshape file system. Significant difference was found at 9mm, 11mm and 12mm between all the three file systems (p<0.001,< 0.001, <0.001). Conclusion: It was concluded that reciprocating motion is better than rotary motion in all the three parameters Canal Transportation, Cross-sectional Area, Cervical Dentinal Thickness. [ABSTRACT FROM AUTHOR]

For protecting sensitive files stored on the flash-based storage devices, this paper presented a file hiding method based on the redundant blocks. Based on analyzing the characteristics of NAND-type fash and the file management mechanism of FAT32 file system, the method made the redundant physical blocks organic combination to store sensitive files, and restored the original files by similar method to hiding. Experimental results show that the file hiding method based on the redundant blocks does not take up the flash effective space, has the characteristics of high concealment, strong robustness, considerable hiding capacity, and can effectively resist the evidence-taken attack of software. [ABSTRACT FROM AUTHOR]

Existing implementations of file systems often seem to be made on an ad hoc and implicit basis. This paper aims to enhance the organization of files and retrieval of files by modifying the traditional hierarchical file system to improve built-in query support and bulk metadata updates supported at the file system level. We introduce tags in a hierarchy of file collections and use links to allow file retrieval from multiple paths as files exist in multiple directories simultaneously. By using a series of modest changes to the hierarchical file system, we propose a novel Linked Tree Tags (LTTs) model. These changes include using multiple tags instead of names, collections instead of directories, exposing a query language at the Application Programming Interface (API) level, and allowing controlled file links. We assess our model's expressive capability and demonstrate that LTTs overcome traditional file systems' limits and provide users with the to manage their files easily. [ABSTRACT FROM AUTHOR]

The backup taken of a file system must be consistent, preserving data integrity across files in the file system. With file system sizes getting very large, and with demand for continuous access to data, backup has to be taken when the file system is active (is online). Arbitrarily taken online backup may result in an inconsistent backup copy. We propose a scheme referred to as mutual serializability to take a consistent backup of an active file system assuming that the file system supports transactions. The scheme extends the set of conflicting operations to include read-read conflicts, and it is shown that if the backup transaction is mutually serializable with every other transaction individually, a consistent backup copy is obtained. The user transactions continue to serialize within themselves using some standard concurrency control protocol such as Strict 2PL. We put our scheme into a formal framework to prove its correctness, and the formalization as well as the correctness proof are independent of the concurrency control protocol used to serialize user transactions. The scheme has been implemented and experiments show that consistent online backup is possible with reasonable overhead. [ABSTRACT FROM AUTHOR]

Digital devices are increasingly being used in various crimes, and therefore, it becomes important for law enforcement agencies to be able to investigate and analyze digital devices. Accordingly, there is an increasing demand for digital forensic technologies which can recover the data concealed or deleted by criminals that are of prime importance. There are various digital forensic tools available for Windows-based systems and relatively a few of those for Linux-based systems. Thus, this paper suggests a deleted file recovery technique for the Ext 2/3 filesystem, which is commonly used in Linux. The research involved the analysis of the Ext filesystem structure, file storage structure, and metadata information of file. The shortcomings of the existing methods and methods implemented by the proposed technique to address them are presented. Further, a comparison of the performance of the proposed technique and that of the existing methods is presented. [ABSTRACT FROM AUTHOR]

The multi-level cell (MLC) NAND flash memory technology enables multiple bits of information to be stored in a memory cell, thus making it possible to increase the density of flash memory without increasing the die size. In MLC NAND flash memory, each memory cell can be programmed as a single-level cell or a multi-level cell at runtime because of its performance/capacity asymmetric programming property, which is called flexible programming in this paper. Therefore, MLC flash memory has a potential to achieve the high performance of SLC flash memory while preserving its maximum capacity. In this paper, we present a flexible flash file system, called FlexFS, which takes advantage of flexible programming. FlexFS divides a flash memory medium into SLC and MLC regions, and then dynamically changes two different types of regions to provide an optimal storage solution to end-users in terms of performance and capacity. FlexFS also provides a reasonable storage lifetime by managing the wearing rate of NAND flash memory, which is accelerated by the use of flexible programming. Our implementation of FlexFS in the Linux 2.6 kernel shows that it achieves the I/O performance comparable to SLC flash memory while guaranteeing the capacity of MLC flash memory in various real-world workloads. [ABSTRACT FROM AUTHOR]

A virtual machine (VM) has been serving as a crucial component in cloud computing with its rich set of convenient features. The high overhead of a VM has been well addressed by hardware support such as Intel virtualization technology (VT), and by improvement in recent hypervisor implementation such as Xen, KVM, etc. However, the high demand on VM image storage remains a challenging problem. Existing systems have made efforts to reduce VM image storage consumption by means of deduplication within a storage area network (SAN) cluster. Nevertheless, an SAN cannot satisfy the increasing demand of large-scale VM hosting for cloud computing because of its cost limitation. In this paper, we propose Liquid, a scalable deduplication file system that has been particularly designed for large-scale VM deployment. Its design provides fast VM deployment with peer-to-peer (P2P) data transfer and low storage consumption by means of deduplication on VM images. It also provides a comprehensive set of storage features including instant cloning for VM images, on-demand fetching through a network, and caching with local disks by copy-on-read techniques. Experiments show that Liquid's features perform well and introduce minor performance overhead. [ABSTRACT FROM AUTHOR]

For protecting sensitive data stored on computer disks, this paper presented a data hiding method based on disk slack space. Based on analyzing disk partitioning scheme and file management mechanism of cluster-based file system, it made dispersed file-cluster slack spaces organic combination to store sensitive data, and maintained data which was used to restore the original data by using data structure which was stored in partitioning-scheme slack spaces. Experimental results show that data hiding method based on disk slack space does not take up the file system effective space, has characteristics of high concealment, low system overhead, positive correlation between hiding capacity and overall number of files within file system, and anti-interference performance is susceptible to the stability of host files. Moreover, hiding capacity will be very considerable when overall number of files is large, and anti-interference performance can be improved by selecting host files with good stability. [ABSTRACT FROM AUTHOR]

To bridge the performance gap between network and storage, performance tuning of file systems according to different workloads has become an important work on the Internet of Things (IoT). However, existing methods on file system tuning mainly focused on tailoring the file system kernel codes, or cannot scope to high dimensional parameters and dynamically changing workloads. In this paper, we propose an automatic I/O performance tuning system FSbrain that recommends reasonable and performance-efficient configurations for file systems by using machine learning. It makes the configuration recommendations based on current workloads within an acceptable time, however, without any manual interventions or kernel code modifications. In specific, FSbrain mainly consists of two phases which are model training and configuration tuning. Since tuning attempts will cause frequent remounting on target file systems, we deploy FSbrain and conduct the tuning sessions on an experimental node called "shadow server". We evaluate FSbrain on three representative file systems (namely, Ext4, F2FS, and PMFS). The experimental results show that the configuration recommended by FSbrain can improve the I/O performance by up to 1.28 × averagely than the default configuration. Besides, FSbrain reduces the overall tuning time by 90% compared to manual tuning. [ABSTRACT FROM AUTHOR]

Versioning file systems are widely used in modern computer systems as they provide system recovery and old data access functions by retaining previous file system snapshots. However, existing versioning file systems do not perform well with the emerging PCM (phase-change memory) storage, because they are optimized for hard disks. Specifically, a large amount of additional writes incurred by maintaining snapshot degrades the performance of PCM seriously as write operations are the performance bottleneck of PCM. This paper presents a novel versioning file system, designed for PCM, that reduces the writing overhead of a snapshot significantly. Unlike existing versioning file systems that incur cascade writes up to the file system root, our scheme breaks the recursive update chain at the immediate parent level. The proposed file system is implemented on Linux 2.6 as a prototype. Measurement studies with various I/O benchmarks show that the proposed file system improves the I/O throughput by 144 percent on average, compared to ZFS, a representative versioning file system. [ABSTRACT FROM PUBLISHER]

In recent years, reliability has become one critical issue in the designs of flash-memory file/storage systems, due to the growing unreliability of advanced flash-memory chips. In this paper, a version-based design is proposed to effectively and efficiently maintain the consistency among page versions of a file for potential recovery needs. In particular, a two-version one for a native file system is presented with the minimal overheads in version maintenance. A recovery scheme is then presented to restore a corrupted file back to the latest consistent version. The design is later extended to maintain multiple data versions with the considerations of the write constraints of multilevel-cell flash memory. It was shown that the proposed design could significantly improve the reliability of flash memory with limited management and space overheads. [ABSTRACT FROM AUTHOR]

In a traditional virtualized cloud environment, using asynchronous I/O in the guest file system and synchronous I/O in the host file system to handle an asynchronous user disk write exhibits several drawbacks, such as performance disturbance among different guests and consistency maintenance across guest failures. To improve these issues, this paper introduces a novel disk I/O model for virtualized cloud system called HypeGear, where the guest file system uses synchronous operations to deal with the guest write request and the host file system performs asynchronous operations to write the data to the hard disk. A prototype system is implemented on the Xen hypervisor and our experimental results verify that this new model has many advantages over the conventional asynchronous-synchronous model. We also evaluate the overhead of asynchronous I/O at host, which is brought by our new model. The result demonstrates that it enforces little cost on host layer. [ABSTRACT FROM AUTHOR]

The existing NAND flash memory file systems have not taken into account multiple NAND flash memories for large-capacity storage. In addition, since large-capacity NAND flash memory is much more expensive than the same capacity hard disk drive, it is cost wise infeasible to build large-capacity flash drives. To resolve these problems, this paper suggests a new file system called NAFS for large-capacity storage with multiple small-capacity and low-cost NAND flash memories. It adopts a new cache policy, mount scheme, and garbage collection scheme in order to improve read and write performance, to reduce the mount time, and to improve the wear-leveling effectiveness. Our performance results show that NAFS is more suitable for large-capacity storage than conventional NAND file systems such as YAFFS2 and JFFS2 and a disk-based file system for Linux such as HDD-RAID5-EXT3 in terms of the read and write transfer rate using a double cache policy and the mount time using metadata stored on a separate partition. We also demonstrate that the wear-leveling effectiveness of NAFS can be improved by our adaptive garbage collection scheme. [ABSTRACT FROM AUTHOR]

This article investigates the transient use of free local storage for improving performance in VM-based mobile computing systems implemented as thick clients on host PCs. We use the term TransientPC systems to refer to these types of systems. The solution we propose, called TransPart, uses the higher-performing local storage of host hardware to speed up performance-critical operations. Our solution constructs a virtual storage device on demand (which we call transient storage) by borrowing free disk blocks from the host's storage. In this article, we present the design, implementation, and evaluation of a TransPart prototype, which requires no modifications to the software or hardware of a host computer. Experimental results confirm that TransPart offers low overhead and startup cost, while improving user experience. [ABSTRACT FROM AUTHOR]

AbFS is a distributed file system that makes it possible to efficiently share the inexpensive devices attached to the commodity computers of a cluster. The implementation of AbFS offers high-performance metadata management by combining hashing and tables in several levels, hierarchical structures and caches, and by combining the attributes and the namespace in the same structure. No additional layers are needed to implement caches because AbFS uses the Linux metadata caches, inode and dentry, to implement them. Along with the description of the proposed implementation for metadata management and the comparison with other implementations, this work provides experimental results to evaluate its performance obtained with a prototype made from scratch at kernel level. AbFS experimental results show that the implementation proposed is capable to manage files and directories with high performance. [ABSTRACT FROM AUTHOR]

Data captured by flight data recorders are generally stored on the system's embedded hard disk. A common problem is the lack of storage space on the disk. This lack of space for data storage leads to either a constant effort to reduce the space used by data, or to increased costs due to acquisition of additional space, which is not always possible. File compression can solve the problem, but carries with it the potential drawback of the increased overhead required when writing the data to the disk, putting an excessive load on the system and degrading system performance. The author suggests the use of an efficient compressed file system that both compresses data in real time and ensures that there will be minimal impact on the performance of other tasks. [ABSTRACT FROM AUTHOR]

An abstract file system is defined here as a partial function from (absolute) paths to data. Such a file system determines the set of valid paths. It allows the file system to be read and written at a valid path, and it allows the system to be modified by the Unix operations for creation, removal, and moving of files and directories. We present abstract definitions (axioms) for these operations. This specification is refined towards a pointer implementation. The challenge is to have a natural abstraction function from the implementation to the specification, to define operations on the concrete store that behave exactly in the same way as the corresponding functions on the abstract store, and to prove these facts. To mitigate the problems attached to partial functions, we do this in two steps: first a refinement towards a pointer implementation with total functions, followed by one that allows partial functions. These two refinements are proved correct by means of a number of invariants. Indeed, the insights gained consist, on the one hand, of the invariants of the pointer implementation that are needed for the refinement functions, and on the other hand of the precise enabling conditions of the operations on the different levels of abstraction. Each of the three specification levels is enriched with a permission system for reading, writing, or executing, and the refinement relations between these permission systems are explored. Files and directories are distinguished from the outset, but this rarely affects our part of the specifications. All results have been verified with the proof assistant PVS, in particular, that the invariants are preserved by the operations, and that, where the invariants hold, the operations commute with the refinement functions. [ABSTRACT FROM AUTHOR]

The traditional hard disk drive (HDD) is often a bottleneck in the overall performance of modern computer systems. With the development of solid state drives (SSD) based on flash memory, new possibilities are available to improve secondary storage performance. In this work, we propose a new hybrid SSD-HDD storage system and a selection of algorithms designed to assign pages across an HDD and an SSD to optimise I/O performance. The hybrid system combines the advantages of the SSD's fast random seek speed with the sequential access speed and large storage capacity of the HDD to produce significantly improved performance in a variety of situations. We further improve performance by allowing concurrent access across the two types of storage devices. We show the drive assignment problem is NP-complete and accordingly propose effective heuristic solutions. Extensive experiments using both synthetic and real data sets show our system with a small SSD can outperform a striped dual HDD and remain competitive with a dual SSD. [ABSTRACT FROM AUTHOR]

The rapid evolution in recent years in all areas of activity has led to the widespread use of computers and automatic processing technologies of data and information. By connecting to the Internet there is also the possibility of an exchange of information between users of the network. For these reason a very important problem for any user of the computer is the security of the dates and the LINUX operating system can to offer this pressing requirement. This article proposes a study on virtual file types that can be used by the LINUX operating system. Through this manner of implementation the LINUX operating system can to use some different types oh file systems: XFS, EXT2, EXT3, JFS and Reiser. For that reason, in the present paper the capacity of LINUX operating system through the mediation of the virtual file system to offer the support for this types of file systems is analyzed. [ABSTRACT FROM AUTHOR]

We explore the possibility of deploying storage class memory (SCM) into the I/O path as a file system metadata store and examine what effects it has on the performance of portable computing systems. In this regard, we develop a new flash memory-based file system that stores all metadata in SCM, while storing all file data in flash memory. In so doing, we make two contributions in this work. First, we present a model that analyzes the amount of SCM that is needed for specific flash memory storage capacity. Second, we present quantitative experimental results that show how much performance gains are possible by exploiting SCM in terms of I/O performance, energy efficiency and lifetime of the underlying flash memory. Compared to YAFFS, a popular flash memory-based file system, we show that system performance is improved by a maximum of around 320, 260, and 180% in terms of I/O performance, energy efficiency and lifetime of the Flash memory, respectively, for the realistic workloads that we considered. [ABSTRACT FROM AUTHOR]

This paper introduces the design and implementation of control platform for the multi-functional self-balancing intelligent car. The design of intelligent car uses MPU9150 sensor to achieve self-balance function. It has GPS position display. The control system has strong robustness so that the car can still remain upright running state within 20° interference. The speed and direction are in closed-loop control, and the speed, angle,low voltage protection are all held. Meanwhile, the car's speed and direction can be controlled through intelligent control platform. Multiple control parameters can be set by a humanized interface. With an SD card based on file system platform, real-time operating data of the car can be recorded. [ABSTRACT FROM AUTHOR]