56 research outputs found
Recommended from our members
The Design and Implementation of Elastic Quotas: A System for Flexible File System Management
We introduce elastic quotas, a disk space management technique that makes disk space an elastic resource like CPU and memory. Elastic quotas allow all users to use unlimited amounts of available disk space while still providing system administrators the ability to control how the disk space is allocated among users. Elastic quotas maintain existing persistent file semantics while supporting user-controlled policies for removing files when the file system becomes too full. We have implemented an elastic quota system in Solaris and measured its performance. The system is simple to implement, requires no kernel modifications, and is compatible with existing disk space management methods. Our results show that elastic quotas are an effective, low-overhead solution for flexible file system management
Usenetfs: A Stackable File System for Large Article Directories
The Internet has grown much in popularity in the past few years. Numerous users read USENET newsgroups daily for entertainment, work, study, and more. USENET News servers have seen a gradual increase in the traffic exchanged between them, to a point where the hardware and software supporting the servers is no longer capable of meeting demand, at which point the servers begin 'dropping' articles they could not process. The rate of this increase has been faster than software or hardware improvements were able to keep up,resulting in much time and effort spent by administrators upgrading their news systems. One of the primary reasons for the slowness of news servers has been the need to process many articles in very large flat directories representing newsgroups such as control. cancel and misc.jobs.offered. A large portion of the resources is spent on processing articles in these few newsgroups. Most Unix directories are organized as a linear unsorted sequence of entries. Large news groups can have hundreds of thousands of articles in one directory, resulting in significant delays processing any single article. Usenetfs is a file system that rearranges the directory structure from being flat to one with small directories containing fewer articles. By breaking the structure into smaller directories, it improves the performance of looking for, creating, or deleting files, since these operations occur on smaller directories. Usenetfs takes advantage of article numbers; knowing that file names representing articles are composed of digits helps to bound the size of the smaller directories. Usenetfs improves overall performance by at least 22\%for average news servers; common news server operations such as looking up, adding, and deleting articles are sped up by as much as several orders of magnitude. Usenetfs was designed and implemented as a stackable Vnode layer loadable kernel module. It operates by 'encapsulating' a client file system with a layer of directory management. To the process performing directory operations through a mounted Usenetfs, all directories appear flat; but when inspecting the underlying storage that it manages, small directories are visible. Usenetfs is small and is transparent to the user. It requires no change to News software, to other file systems, or to the rest of the operating system. Usenetfs is more portable than other native kernel-based file systems because it interacts with the Vnode interface which is similar on many different platforms
Framework for implementing file systems in Windows NT
Thesis (S.B. and M.Eng.)--Massachusetts Institute of Technology, Dept. of Electrical Engineering and Computer Science, 1998.Includes bibliographical references (p. 38-39).by Danilo Almedia.S.B.and M.Eng
Recommended from our members
Performance of Size-Changing Algorithms in Stackable File Systems
Stackable file systems can provide extensible file system functionality with minimal performance overhead and development cost. However, previous approaches are limited in the functionality they provide. In particular, they do not support size-changing algorithms, which are important and useful for many applications, such as compression and security. We propose fast index files, a technique for efficient support of size-changing algorithms in stackable file systems. Fast index files provide a page mapping between file system layers in a way that can be used with any size-changing algorithm. Index files are designed to be recoverable if lost and add less than 0.1\% disk space overhead. We have implemented fast indexing using portable stackable templates, and we have used this system to build several example file systems with size-changing algorithms. We demonstrate that fast index files have very low overhead for typical workloads, only 2.3\% over other stacked file systems. Our system can deliver much better performance on size-changing algorithms than user-level applications, as much as five times faster
Distributed file systems for Unix
With the advent of distributed systems, mechanisms that support efficient resource sharing are necessary to exploit a distributed architecture. One of the key resources UNIX provides is a hierarchical file system. Early efforts supported distributed UNIX systems by copying files and sending mail between individual machines. The desire to provide transparent mechanisms on which distributed systems access resources has propelled the development of distributed file systems. This thesis presents a brief history of the development of distributed systems based on UNIX, and surveys recent implementations of distributed file systems based on UNIX. The IBIS distributed file system is an example of the latter. The original capabilities of IBIS are discussed and modifications that enhance these capabilities described
Advancing Operating Systems via Aspect-Oriented Programming
Operating system kernels are among the most complex pieces of software in existence to-
day. Maintaining the kernel code and developing new functionality is increasingly compli-
cated, since the amount of required features has risen significantly, leading to side ef fects
that can be introduced inadvertedly by changing a piece of code that belongs to a completely
dif ferent context.
Software developers try to modularize their code base into separate functional units.
Some of the functionality or “concerns” required in a kernel, however, does not fit into
the given modularization structure; this code may then be spread over the code base and
its implementation tangled with code implementing dif ferent concerns. These so-called
“crosscutting concerns” are especially dif ficult to handle since a change in a crosscutting
concern implies that all relevant locations spread throughout the code base have to be
modified.
Aspect-Oriented Software Development (AOSD) is an approach to handle crosscutting
concerns by factoring them out into separate modules. The “advice” code contained in
these modules is woven into the original code base according to a pointcut description, a
set of interaction points (joinpoints) with the code base.
To be used in operating systems, AOSD requires tool support for the prevalent procedu-
ral programming style as well as support for weaving aspects. Many interactions in kernel
code are dynamic, so in order to implement non-static behavior and improve performance,
a dynamic weaver that deploys and undeploys aspects at system runtime is required.
This thesis presents an extension of the “C” programming language to support AOSD.
Based on this, two dynamic weaving toolkits – TOSKANA and TOSKANA-VM – are presented
to permit dynamic aspect weaving in the monolithic NetBSD kernel as well as in a virtual-
machine and microkernel-based Linux kernel running on top of L4. Based on TOSKANA,
applications for this dynamic aspect technology are discussed and evaluated.
The thesis closes with a view on an aspect-oriented kernel structure that maintains
coherency and handles crosscutting concerns using dynamic aspects while enhancing de-
velopment methods through the use of domain-specific programming languages
- …