Course: cosc513 Operating System Name: Jing Bai Date: 8/28/00

Course: COSC513 Operating System Name: Jing Bai Date:8/28/00
Contents:
Introduction ------------------------------------------------------------------------( 1 )
Design Principles ------------------------------------------------------------------( 3 )
File system -------------------------------------------------------------------------( 9 )
Memory management -------------------------------------------------------------(12 )
Security -------------------------------------------------------------------------------(15 )
Conclusion ---------------------------------------------------------------------------(16 )
Reference ----------------------------------------------------------------------------( 17 )
Figure----------------------------------------------------------------------------------(20)
Compare Windows NT with Unix System
INTRODUCTION:
Operating system is an essential part of any computer system. It provides the environment for user who can execute program conveniently. After over 40 years developed, many operating systems have been adopted by different companies and researches. UNIX is one of successful operating system. Ken Thompson developed it in 1969, it is a machine independent operating system. The UNIX system was designed by programmers for programmers. Thus it has always been interactive, and facilities for program development have always been a high priority. Time-sharing , multi-user, multi-tasking are basic designed in this system. Multiple users can have multiple tasks running simultaneously. UNIX operating system was written by programmer to programmer, it use C language to instead of the previously used assembly language, because these early advantages, it lead UNIX’s popularity at education, research, and government institutions and eventually in the commercial world.
Windows NT operating system is a preemptive multitasking operating system for modern microprocessors. Microsoft released it in 1993, NT is portable to a variety of processor architectures. The design goals for NT include extensibility, portability, reliability, compatibility, performance and international support. NT was a full 32-bit operating system that included various subsystems that could handle the tasks of running 16-but DOS applications, 16-bit windows applications. Application written to the portable operating system interface for computing environments(POSIX) API, and character-based OS/2 applications.
Architecture
UNIX SYSTEM :
UNIX is a machine independent operating system. It is a multi-user, multi-tasking operating system. That means, Multiple users may have multiple tasks running simultaneously. it is a time-sharing system. UNIX was designed to be a time-sharing system. The standard user interface (the shell) is simple and can be replaced by another . the file system is a multilevel tree which allows users to create their own subdirectories. Each user data file is simply a sequence of bytes.
Disk files and I/O devices are treated as similarly as possible. Thus, device dependencies and peculiarities are kept in the kernel as much as possible; even in the kernel, most of them are confined to the device drivers.
UNIX supports multiple processes. A process can easily create new processes. CPU scheduling is a simple priority algorithm. Swapping is used if a system is suffering from excess paging.
UNIX consists of two separable parts: the kernel and systems programs. As figure 1. Everything below the system-call interface and above the physical hardware is the kernel. The kernel provides the file system, CPU scheduling, memory management, and other operating-system functions through system calls. Systems programs use the kernel supported system calls to provide useful functions, such as compilation and file manipulation.
System calls define the programmer interface to UNIX, the set of systems programs commonly available defines the user interface. The programmer and user interface define the context that the kernel must support. System calls for UNIX can be roughly grouped into three categories: file manipulation, process control, and information manipulation.
File Manipulation: A file in UNIX is a sequence of bytes. Different programs expect various levels of structure, but the kernel does not impose a structure on files. Files are organized in tree-structured directories. Directories are themselves files that contain information on how to find other files. A path name to a file is a text string that identifies a file by specifying a path through the directory structure to the file. The UNIX file system has both absolute path names and relative path names. Absolute path names start at the root of the file system and are distinguished by a slash at the beginning of the path name; relative path names start at the current directory which is an attribute of the process accessing the path name. a file may be known by more than one name in one or more directories.
Process Control: A process is a program in execution. Processes are identified by their process identifier. A new process is created by the fork system call. The new process consists of a copy of the address space of the original process. The execute system call is used after a fork by one of the two processes to replace that process virtual memory space with a new program. The execute system call loads a binary file into memory and starts its execution. A process may terminate by using the exit system call, and its parent process may wait for that event by using the wait system call. If the child process crashes, the system simulates the exit call. The wait system call provides the process id of a terminated child so that the parent can tell which of possibly many children terminated.
Information Manipulation: The system-calls exist to set and return both an interval timer and the current time in microseconds. In addition, processes can ask for their process identifier, their group identifier , the name of machine on which they are executing and many other values.
WINDOWs NT 4.0
Windows NT operating system is a preemptive multitasking operating system for modern microprocessors. NT is portable to a variety of processor architectures. The key goals for NT include extensibility, Portability, reliability, compatibility, performance and international support.
Extensibility is an important property of any operating system that hopes to keep up with advancements in computing technology. So that changes are facilitated over time, NT is implemented using a layered architecture. The NT executive, which runs in kernel or protected mode, provides the basic system services. On top of the executive, several server subsystems operate in user mode. Among these are environmental subsystems that emulate different operating systems. Thus, programs written for MS-DOS, Microsoft windows and OOSIX can all run on NT in the appropriate environment.
An operating system is portable if it can be moved from one hardware architecture to another with relatively few changes. NT is designed to be portable. As is true of UNIX, the majority of the system is written in C . all processor-dependent code is isolated in a dynamic link library(DDL),called the hardware abstraction layer(HAL). A DLL is a file that gets mapped into a process’s address space such that any functions in the DLL appear as if they are part of the process. The upper layers of NT depend on HAL, rather than on the underlying hardware, and that helps NT to be portable. The HAL manipulates hardware directly, isolating the rest of NT from hardware differences among the platforms on which it runs.
Reliability is the ability to handle error conditions, including the ability of the operating system to protect itself and its users from defective or malicious software. NT is designed to resist defects and attacks by using hardware protection for virtual memory, and software protection mechanisms for operating system resources. Also , NT comes with a file system called the NT file system (NTFS) that recovers automatically from many kinds of file system errors after a system crash.
NT provides source-level compatibility to applications. Thus, they can be compiled to run on NT without changing the source code.
NT is designed to afford good performance. The subsystems that comprise NT can communicate with one another efficiently by a local-procedure-call facility that provides high-performance message passing. Except for the kernel, threads in the subsystems of NT can be preempted by higher-priority threads. Thus the system can respond quickly to external events. In addition, NT is designed for symmetrical multiprocessing: ON a multiprocessor computer, several threads can run at the same time.
NT is also designed for international use. It provides support for different locales via the national language support(NLS)API.
The architecture of NT is a layered system of modules. Figure2 shows the architecture of NT. The main layers are the hardware abstraction layer, the kernel and the executive that run in protected mode, and a large collection of subsystems that run in user mode. The use-mode subsystems are in two categories. The environmental subsystems emulate different operating systems; the protection subsystems provide security functions. One of the chief advantages of this type of architecture is that interactions between modules can be kept simple. HAL is a layer of software that hides hardware differences from upper levels of the operating system, to help make NT portable. HAL also provides the support for symmetric multiprocessing.
The kernel (figure 2) of NT provides the foundation for the executive and the subsystems. The kernel is never paged out of memory and its execution is never preempted. It has four main responsibilities: thread scheduling, interrupt and exception handling, low-level processor synchronization and recovery after a power failure. The kernel is object oriented. An object type in NT is a system-defined data type that has a set of attributes and a set of methods. An object is just an instance of a particular object type. The kernel has two sets of objects. The first set of objects are the dispatcher object. These control dispatching and synchronization in the system. Such as events, mutants, mutexes, semaphores, threads , and timers. The second set of objects comprises the control object. These objects include asynchronous procedure calls, interrupts, power notify, power status, process, and profile objects.
FILE SYSTEM:
UNIX:
UNIX file is a Hierarchical File Structure( figure 3). All of the files in the UNIX file system are organized into a multi-leveled hierarchy called a directory tree. Files are supported by the kernel as unstructured sequences of bytes. Files and directories are main objects in this system. File are stored as an array of fixed-size data blocks with perhaps a trailing fragment. Data blocks contain whatever the users have put in their files. The block and fragment sizes are set during file-system creation according to the intended use of the file system: if many small files are expected, the fragment size should be small; if repeated transfers of large files are expected the basic block size should be large.
The data blocks are found by pointers in the inode. An inode is a record that stores most of the information about a specific file on the disk. The name inode is derived from “index node” and was originally spelled “I-node”. The inode contains the user and group identifiers of the file, the times of the last file modification and access, a count of the number of hard links. In addition, the inode contains 15 pointers to the disk blocks containing the data contents of the file. The first 12 of these pointers point to direct blocks; that is, they contain addresses of blocks that contain data of the file. Thus, the small files can be referenced immediately, because a copy of the inode is kept in main memory while a file is open. The next three pointers in the inode point to indirect blocks.
There is no distinction between plain files and directories at this level of implementation; directory contents are kept in data blocks, and directories are represented by an inode in the same way. File names are of variable length, so directory entries are also of variable length. The user refers to a file by a path name, whereas the file system uses the inode as its definition of a file. Nondisk files do not have data blocks allocated on the disk. The kernel notices these file types and calls appropriate drivers to handle I/O for them . Once the inode is found by , the open system call, a file structure is allocated to point to the inode. The file descriptor given to the user refers to this file structure.
System calls that refer to open files indicate the file by passing a file descriptor as an argument. The file descriptor is used by the kernel to index a table of open files for the current process. Each entry of the table contains a pointer to a file structure. This file structure in turn points to the inode. The open file table has a fixed length which is only Settle at boot time. Therefore there is a fixed limit on the number of concurrently open files in a system. The inode structure pointed to by the file structure is an in-core copy of the inode on the disk.
The file system that the user sees is supported by data on a mass storage device---a disk. The user ordinarily knows of only one file system, but this one logical file system may actually consist of several physical file systems, each on a different device. Partitioning a physical device into multiple file systems has several benefits. Different file systems can support different uses. Although most partitions would be used by the file system, at least one will be necessary for a swap area for the virtual-memory software.
Windows NT:
MS-DOS systems have used the file allocation table(FAT) file system. The 16 bit FAT file system has several shortcomings, including internal fragmentation, a lack of access protection for files. The 32-bit FAT file system has solved the size and fragmentation problems, but the performance and features are still weak by comparison with modern file systems. The NTFS is much better on the performance. It was design with many features, including data recovery, security, fault tolerance, large files and file systems, multiple data streams, and file compression. For compatibility, NT provides support for the FAT and OS/2 file systems .
The fundamental entity in NTFS is a volume. A volume is created by the NT disk administrator utility, and is based on a logical disk partition. The volume may occupy a portion of a disk, may occupy an entire disk, or may span across several disks.
NTFS does not deal with individual sectors of a disk, but instead uses clusters as the unit of disk allocation. A cluster is a number of disk sectors that is a power of 2. The clusters size is configured when an NTFS file system is formatted.
NTFS uses logical cluster numbers (LCNs) as disk addresses. It assigns them by numbering clusters from the beginning of the disk to the end. Using this scheme, the system can calculate a physical disk offset by multiplying the LCN by the cluster size.
A file in NTFS is not a simple byte stream, as it is in MS-DOS or Unix; rather, it is a structured object consisting of attributes. Each attribute of a file is an independent byte stream that can be created, deleted, read, and written.
Every file in NTFS is described by one or more records in an array stored in a special file called the master file table(MFT).
Memory Management:
UNIX:
Unix systems use swapping exclusively to handle memory contention among processes. If there is too much contention, processes are swapped out until enough memory is available. Also, a few large processes can force many small processes out of memory, and a process a larger than non kernel main memory can not be run at all. The system data segment and the user data segment are kept in contiguous main memory for swap-transfer efficiency, so external fragmentation of memory can be a serious problem.
Allocation of both main memory and swap space is done first-fit. When the size of a process’ memory image increases, a new piece of memory big enough for the whole image is allocated. The memory image is copied, the old memory is freed, and the appropriate tables are updated.
There is no need to swap out a sharable text segment, because it is read only, and there is no need to read in a sharable text segment for a process when another instance is already in core. That is one of the main reasons for keeping track of sharable text segments: less swap traffic.
Decisions regarding which processes to swap in or out are made by the scheduler process. The scheduler wakes up at least once every 4 seconds to check for processes to be swapped in or out. A process is more likely to be swapped out if it is idle, has been in main memory a long time, or is large; if no obvious candidates are found, other processes are picked by age. A process is more likely to be swapped in if it has been swapped out a long time, or is small.
Memory management is swapping supported by paging. External fragmentation of memory is eliminated by paging. Swapping can be kept to a minimum because more jobs can be kept in main memory. because paging allows execution with only parts of each process in memory.
Demand paging is done in a straightforward manner. When a process needs a page and the page is not there, a page fault to the kernel occurs, a frame of main memory is allocated, and the proper disk page is read into the frame. There are a few optimizations. If the page needed is still in the page table for the process, but has been marked invalid by the page-replacement process, it can be marked valid and used without any I/O transfer. If the page has to be fetched from disk, it must be locked in memory for the duration of the transfer. This locking ensures that the page will not be selected for page replacement.
A page demand process uses a modified second-chance page -replacement algorithm to keep enough free frames to support the executing processes.
Windows NT:
As an object-oriented system NT uses objects for all its services and entities. The NT executive provides a set of services , such as object manager, virtual memory manager, process manager, I/O manager and security reference monitor. The object manager can also keep track of which processes are using each object. Each object header contains a count of the number of processes that have handles to that object. When the counter goes to zero, the object is deleted from the name space (temporary object name). In NT system, object names are structured like file path names in UNIX. UNIX file systems have symbolic links, so multiple nicknames or aliases can refer to the same file. Similarly, NT implements a symbolic link object. One was that NT uses symbolic links is to map drive names to the standard MS_DOS drive letters. The drive letters are just symbolic links that may be remapped to suit the user’s preferences.
The virtual-memory manager portion of the NT executive is the virtual-memory manager. The design of the VM manager assumes that the underlying hardware supports virtual-to –physical mapping, a paging mechanism, transparent cache coherence on multiprocessor systems, and allows multiple page-table entries to map to the same page size. The VM manager in NT uses a page-based management scheme with a page size of 4KB. Pages of data that are assigned to a process but are not in physical memory are stored in the paging file on disk.
The VM manager uses 32-bit addresses, so each process has a 4 GB virtual address space. The upper 2GB is identical for all processes, and is used by NT in kernel mode. The lower 2GB is distinct for every process, and is accessible by both user-and kernel-mode threads.
The NT VM manager uses a two-step process to allocate memory. The first step reserves a portion of the process’s address space. The second step commits the allocation by assigning space in the NT paging file. NT can limit the amount of paging file space that a process consumes by enforcing a quota on committed memory. A process can uncommitted memory that it is no longer using to free up its paging quota.
For performance, the VM manager allows a privileged process to lock selected pages in physical memory, thus ensuring that the pages will not be swapped out to the paging file. The NT process manager provides services for creating, deleting, and using threads and processes. The I/O manager is responsible for file systems , cache management, device drivers, and network drivers. It keeps track of which installable filde systems are loaded, and manages buffers for I/O requests.
Security
Windows NT is a relatively new operating system, it support a variety security features and levels that range from minimal security to Government level C2 security classification. A utility program is provided to choose the desired security settings. Security for file, user, and connection levels is critical with today's interconnected networks. NT has inbuilt security mechanisms. It is build from the ground up with security and maintains it’s own security database, with user names and passwords. Files and directories under Windows NT can be protected . With the NT File System (NTFS), files are protected under Windows NT even when the PC is booted from a floppy disk. the object-oriented nature of NT enables the use of a uniform mechanism to perform run-time access validation and audit checks for every entity in the system. Each file object has a security-descriptor attribute stored in its MFT record.
UNIX: is representative, providing read, write, and execution protection separately for the owner, group, and general public for each file. UNIX system uses encryption to avoid the necessity of keeping its password list secret. Firewall is one of approach to implementing security. The firewall methods of implementing access controls and overall transitive effect of the various layers upon the adjacent layers. The upper layers overshadow or are transitive to the layers below. It is intended that the UNIX server at this layer will be dedicated to this role and not otherwise used to provide general network resources.
COMPARED UNIX & WINDOWS NT File System
UNIX SYSTEM
|
Windows NT SYSTEM
|
Hierarchical file structure
File and Directory
Block
FAT(File allocation table)
Inode ( Index Node)
|
32 bits
NTFS
Volume
Clusters
MFT (Master file table)
|
Memory Management
UNIX SYSTEM
|
Windows NT SYSTEM
| |
VM ( Virtual-memory manager)
Paging File
|
Others
UNIX SYSTEM
|
Windows NT SYSTEM
|
Mature and cheaper
More reliability and stability
Configuration do not require a shutdown and reboot
Setting keyboard and mouse
|
Immature and expensive
Have to buy separate software to set-up e_mail system
More crash than Unix
Less stability than Unix
|
Conclusion:
Unix is a powerful operating system because its early advantage, it led Unix’s popularity at education, research, and government institutions and eventually in the commercial world. In recent years, Linux and other UNIX-like system had been designed to run as many standard Unix applications. They provide a programming interface and user interface compatible with standard Unix systems, and can run a large number of Unix applications, including an increasing number of commercially supported applications. As Unix and Linux has more matured and reliable,
Windows NT is a new operating system. Compared with Unix system, it is still young. The reliability is still has some problem. One of the main problems with windows NT is that they haven'’ had quite enough time to really mold their product and work the kinds out. Although windows NT is still new to the network operating system market, their application server rates very high but unfortunately their ratings are not as high in other categories.
Reference:
1. “Examining the windows NT file system” , Dr.Dobb’s Journal, February 1997
2. “Advances in windows NT storage Management”, Luis Felips, Brian Andrew IEEE 1998
http://www.microsoft.com
“Operating system concepts (fifth edition)”, Sliberschatz Galvin, 1997
http://www.boiz.com/topten.html
http://www.techweb.com
http://www.vmirror.com
http://www.pythonprox.com
http://tcbworks.cba.uga.edu/adennis/
“Distributed Systems”, second Edition, S.Mullender, New York, NY 1997
|