Case study

MS-DOS: A Brief Introduction
MS-DOS (Microsoft Disk Operating System) is a single-user, single-tasking computer operating system that uses
a command line interface. In spite of its very small size and relative simplicity, it is one of the most successful
operating systems that has been developed to date.
A Quick and Dirty History
When IBM launched its revolutionary personal computer, the IBM PC, in August 1981, it came complete with a 16-
bit operating system from Microsoft, MS-DOS 1.0. This was Microsoft's first operating system, and it also became
the first widely used operating system for the IBM PC and its clones.
MS-DOS 1.0 was actually a renamed version of QDOS (Quick and Dirty Operating System), which Microsoft bought
from a Seattle company, appropriately named Seattle Computer Products, in July 1981. QDOS had been developed as
a clone of the CP/M eight-bit operating system in order to provide compatibility with the popular business
applications of the day such as WordStar and dBase. CP/M (Control Program for Microcomputers) was written by
Gary Kildall of Digital Research several years earlier and had become the first operating system for microcomputers
in general use.
QDOS was written by Tim Paterson, a Seattle Computer Products employee, for the new Intel 16-bit
8086 CPU (central processing unit), and the first version was shipped in August, 1980. Although it was completed in
a mere six weeks, QDOS was sufficiently different from CP/M to be considered legal. Paterson was later hired by
Microsoft.
Microsoft initially kept the IBM deal a secret from Seattle Computer Products. And in what was to become another
extremely fortuitous move, Bill Gates, the not uncontroversial co-founder of Microsoft, persuaded IBM to let his
company retain marketing rights for the operating system separately from the IBM PC project. Microsoft renamed it
PC-DOS (the IBM version) and MS-DOS (the Microsoft version). The two versions were initially nearly identical,

but they eventually diverged.
The acronym DOS was not new even then. It had originally been used by IBM in the 1960s in the name of an
operating system (i.e., DOS/360) for its System/360 computer. At that time the use of disks for storing the operating
system and data was considered cutting edge technology.
Until its acquisition of QDOS, Microsoft had been mainly a vendor of computer programming languages. Gates and
co-founder Paul Allen had written Microsoft BASIC and were selling it on disks and tape mostly to PC hobbyists.
MS-DOS soared in popularity with the surge in the PC market. Revenue from its sales fueled Microsoft's phenomenal
growth, and MS-DOS was the key to company's rapid emergence as the dominant firm in the software industry. This
product continued to be the largest single contributor to Microsoft's income well after it had become more famous for
Windows.
Subsequent versions of MS-DOS featured improved performance and additional functions, not a few of which were
copied from other operating systems. For example, version 1.25, released in 1982, added support for double-sided
disks, thereby eliminating the need to manually turn the disks over to access the reverse side.
Version 2.0, released the next year, added support for directories, for IBM's then huge 10MB hard disk drive (HDD)
and for 360KB, 5.25-inch floppy disks. This was followed by version 2.11 later in the same year, which added
support for foreign and extended characters.
Version 3.0, launched in 1984, added support for 1.2MB floppy disks and 32MB HDDs. This was soon followed by
version 3.1, which added support for networks.
Additions and improvements in subsequent versions included support for multiple HDD partitions, for
disk compression and for larger partitions as well as an improved disk-checking utility,
enhanced memory management, a disk defragmenter and an improved text editor.
The final major version was 7.0, which was released in 1995 as part of Microsoft Windows 95. It featured close
integration with that operating system, including support for long filenames and the removal of numerous utilities,
some of which were on the Windows 95 CDROM. It was revised in 1997 with version 7.1, which added support for
the FAT32 filesystem on HDDs.
Although many of the features were copied from UNIX, MS-DOS was never able to come anywhere close to UNIX

in terms of performance or features. For example, MS-DOS never became a serious multi-user
or multitasking operating system (both of which were core features of UNIX right from the start) in spite of attempts
to retrofit these capabilities. Multitasking is the ability for a computer to run two or more programs simultaneously.
The Rise of the GUI
The introduction of the Apple Macintosh in 1984 brought about a surge of interest in GUIs (graphical user interfaces),
and it soon became apparent that they would eventually replace command line interfaces such as that used by MS-
DOS. Although many MS-DOS application programs created their own primitive GUIs, this approach required
duplication of programming effort, and the lack of a consistent GUI among programs made it more difficult for users
to learn new programs.
It took Microsoft years until it was able to offer a fairly high quality GUI of its own, with the introduction of
Windows 95 in 1995 (or arguably with Windows 3.0 in 1990). Microsoft had also begun work on a joint project with
IBM called OS/2, which was originally a protected-mode version of MS-DOS with a GUI, but Microsoft soon
abandoned the project in order to devote more resources to the development of Windows NT, a completely new
operating system that was independent of MS-DOS.
Protected mode and real mode are the two modes of operation supported by the Intel x86 architecture. The former
enables 32-bit memory addressing, thereby permitting use of the extended memory that cannot be easily accessed
from real mode. This makes it possible to assign separate memory areas to the operating system kernel (i.e., the core
of the operating system) and to each process (i.e., program or task), thus resulting in much more stable multitasking
than can be attained with real mode.
Early versions of Microsoft Windows ran under MS-DOS, whereas later versions were launched under MS-DOS but
were then extended by going into protected mode. Windows NT and its successors, Windows 2000 and XP, do not
use MS-DOS; however, they contain an emulation layer on which MS-DOS programs can be operated, mainly for
backward compatibility with legacy (i.e., old) software.
DOS Commands
MS-DOS has a relatively small number of commands, and an even smaller number of commonly used ones.
Moreover, these commands are generally inflexible because, in contrast to Linux and other Unix-like operating

systems, they are designed to accommodate few options or arguments (i.e., values that can be passed to the
commands).
Some of the most common commands are as follows (corresponding commands on Unix-like operating systems are
shown in parenthesis):
CD - changes the current directory (cd)
COPY - copies a file (cp)
DEL - deletes a file (rm)
DIR - lists directory contents (ls)
EDIT - starts an editor to create or edit plain text files (vi, vim, ed, joe)
FORMAT - formats a disk to accept DOS files (mformat)
HELP - displays information about a command (man, info)
MKDIR - creates a new directory (mkdir)
RD - removes a directory (rmdir)
REN - renames a file (mv)
TYPE - displays contents of a file on the screen (more, cat)
Comparison between MS-DOS and Linux
MS-DOS and Linux have much in common, primarily because MS-DOS copied many ideas from UNIX. However,
there are some very fundamental differences, including:
(1) Linux is a full-fledged multiuser, multitasking operating system, whereas MS-DOS is a single-user, single-tasking
operating system.
(2) MS-DOS does not have built-in security concepts such as file-ownership and permissions, which are fundamental
to Linux.
(3) Linux has an inverted tree-like filesystem in which all directories and files branch from a single directory, i.e.,
the root directory, and its subdirectories. MS-DOS can have multiple, independent root directories, such as A:, C:, D:,
etc.
(4) Linux uses forward slashes "/" to separate directories, whereas MS-DOS uses backslashes "" for the same

purpose.
(5) Linux filenames can contain up to 255 characters. MS-DOS filenames are limited to an eight characters plus a
three-character extension and have restrictions on allowable characters. Also, filenames are case-sensitive in Linux,
whereas they are not in MS-DOS.
(6) Linux has a vastly richer command set than does MS-DOS, with a much greater number of commands and
individual commands having greater power, flexibility and ease of use. Commands are case-sensitive in Linux, but
they are not in MS-DOS.
(7) Although Linux and MS-DOS both have pipes and input/output redirection, the MS-DOS pipes use a completely
different -- and inferior -- implementation.
(8) MS-DOS is not sufficiently flexible and efficient to serve as a base for a high quality, general-purpose GUI (and
thus it had to be abandoned by Microsoft). In sharp contrast, Linux is an excellent base for a GUI (and it is used as a
base for the X Window System, which is extremely configurable and whose already excellent performance continues
to improve).
MS-DOS Clones and Emulators
The great success of MS-DOS led to the development of several similar operating systems, including DR-DOS,
FreeDOS, OpenDOS and PC-DOS. The most promising of these clones is FreeDOS, which is claimed to be the only
free operating system that is fully compatible with MS-DOS.
Development of FreeDOS was begun in 1994 by Jim Hall, then a physics student at the University of Wisconsin-
River Falls. His motivation was Microsoft's announcement that it would stop supporting MS-DOS because of its
impending replacement by Windows 95.
Like MS-DOS, FreeDOS is lean and robust, and it can run on old hardware and in embedded systems. A major
improvement as compared with MS-DOS is the addition of options to the commands. Moreover, FreeDOS is released
under the GPL (although some software in the distribution is covered by other licenses), thus making it ideal for
bundling a version of DOS into products without having to pay royalties.
Because Linux was originally developed on PCs and at a time when MS-DOS was the dominant PC operating

system, a variety of tools were developed to help developers and users bridge the gap between the two operating
systems. Among them is dosemu, a DOS emulator which is included with Red Hat and other distributions and on
which it is possible to run DOS programs. Emulators are also available for running DOS on other Unix-like operating
systems, even on non-x86 processors.
mtools is a collection of utilities that make it easy to access an MS-DOS floppy disk from Linux by merely inserting
it into the floppy disk drive and without having to use any mounting commands (which can be tricky for
inexperienced users). Included in mtools are more than 20 commands, all of which are identical to their MS-DOS
counterparts except that the letter m is added to the start of each of their names and forward slashes are used instead
of backslashes. For example, the MS-DOS command type a:file1.txt to display the contents of a file
named file1.txt that is located on a floppy disk would become mtype a:/file1.txt.
Outlook For the Future
Although it is widely believed that MS-DOS is an antiquated and useless operating system with few features and
capabilities, this is far from correct. In fact, although not generally publicized, MS-DOS is still used today by
numerous businesses and individuals around the world. A good analogy is the ancient programming language
COBOL (introduced in 1960!), which is still in widespread use and, amazingly, accounts for roughly half of all the
computer code still in existence. Both MS-DOS and COBOL have survived for so long because they are robust,
relatively simple and continue to get the job done with a minimum of maintenance.
In many cases, it was not MS-DOS itself that was the limiting factor in system performance; rather, it was the
hardware, including small memories, slow CPUs and slow video cards. The capabilities of MS-DOS have, in fact,
continued to increase even after Microsoft Windows became widespread. This is a result of continuing advances in
the hardware and the introduction of new or improved utilities and applications. DOS as a whole is also being
strengthened by the improvements that are being made to the MS-DOS clones, particularly FreeDOS.
DOS will be around for many years into the future not only because of the continued existence of legacy applications
but also because of the development of new applications. The main area of growth will most likely be simple
embedded applications, for which DOS is eminently well suited because of its extremely small size, very reliable
operation and zero cost (in the case of FreeDOS).
DOS is so tiny, in fact, that it can fit on a single floppy disk and still leave sufficient room on the same disk for an
embedded program and data files. Although there are many alternatives for embedded systems, including embedded

Linux and Microsoft Windows CE, DOS can be the best choice if space is severely limited. Moreover, in contrast to
FreeDOS, Windows CE has the disadvantages of not being free and having various licensing issues with which to
contend.
UNIX OPERATING SYSTEM CASE STUDY
Prashantpandey
08-30 12:17
1. Unix
2. operatingsystems
PRASHANT PANDEY P4
UNIX CASE STUDY
Table of Contents

1. Introduction -----------------------------------------------------------------3
1. Design principle -----------------------------------------------------------4
2. User interface ---------------------------------------------------------------6
3. Process management ------------------------------------------------------7
4. Memory management ------------------------------------------------------7
5. File system -------------------------------------------------------------------8
6. Inter-process Communication --------------------------------------------10
7. Protection & security ------------------------------------------------------11
Introduction

Older operating systems are monolithic, that is, the whole operating system is a single a.out file that runs in kernel
mode. This binary contains the process management, memory management, file system and the rest. Examples of such
systems are UNIX, MS-DOS, VMS, MVS, OS/360 and MULTICS.
UNIX was originally developed in a laboratory at AT&T’s Bell Labs (now an independent corporation known as Lucent
Technologies).
Unix is a mature, technically superior group of operating systems with almost thirty years of continual development,
performed often by volunteers who believe in what they’re doing, has produced a group of operating systems and
extremely powerful multiprocessor server hardware tailor-made to its needs, whose performance is still unparalleled by
Intel hardware.
The alternative is a micro kernel-based system, in which most of the OS run as separate processes, mostly outside the
kernel. They communicate by message passing. The kernel's job is to handle the message passing, interrupt handling,
low-level process management, and possibly the I/O. Examples of this design are the Chorus, Mach, RC4000 and
Amoeba
Chorus was a research project on distributed systems at INIRA in France. It was bought by Sun Microsystems in 1997.
The Chorus operating system is a highly scalable and reliable embedded operating system that has established itself
among top telecom suppliers. The Chorus operating system is used in public switches and PBXs, as well as within
access networks, cross-connect switches, voice-mail systems, cellular base stations, web-phones and cellular
telephones.
An open and flexible solution, the Chorus operating system also allows developers to rapidly respond to customer needs
and market conditions by quickly and cost-effectively creating and deploying new services and mission-critical
applications. With enhanced networking features, the Chorus operating system seamlessly supports third-party protocol
stacks, legacy applications, real-time and Java technology-based applications simultaneously on a single hardware
platform.

In this paper, I discuss the relative merits and demerits of the two operating systems. A sub-section on Analysis and
Evaluation of operating systems in comparison is provided at the end of each chapter.
Design Principle
A Chorus system is composed of a small nucleus and a set of system servers, which cooperate in the context of
subsystems.
Chorus Nucleus is not the core of a specific operating system; rather it provides generic tools designed to support a
variety of host subsystems, which can coexist on top of the Nucleus.
This structure supports application programs, which already run on an existing operating system, by reproducing the
operating system’s interface within a subsystem.
This classic idea of separating the functions of the operating system into groups of services provided by autonomous
servers is central to the Chorus philosophy. In monolithic systems, these functions are usually part of the “kernel”. This
separation of functions increases modularity, and therefore the portability of the overall system.
Unix is a layered operating system. The innermost layer is the hardware that provides the services for the OS. The
operating system, referred to in Unix as the kernel, interacts directly with the hardware and provides the services to the
user programs. These user programs don't need to know anything about the hardware. They just need to know how to
interact with the kernel and it's up to the kernel to provide the desired service. One of the big appeals of Unix to
programmers has been that most well written user programs are independent of the underlying hardware, making them
readily portable to new systems.
User programs interact with the kernel through a set of standard system calls. These system calls request services to
be provided by the kernel. Such services would include accessing a file: open close, read, write, link, or execute a file;
starting or updating accounting records; changing ownership of a file or directory; changing to a new directory; creating,
suspending, or killing a process; enabling access to hardware devices; and setting limits on system resources.
Unix is a multi-user, multi-tasking operating system. You can have many users logged into a system simultaneously,
each running many programs. It's the kernel's job to keep each process and user separate and to regulate access to
system hardware, including cpu, memory, disk and other I/O devices.

User Interface
Analysis and Evaluation:
Programmers and users mainly deal with already existing systems programs; the needed system calls are embedded
within the program and do not need to be obvious to the user.
The most common systems programs are file or directory oriented.
 Directory:mkdir,rmdir,cd,pwd
 File:ls,cp,mv,rm
Other programs relate to editors (e.g.,emacs,vi), text formatters (e.g., troff, TEX), and other activities.
Shell – the user process, which executes programs (also called command interpreter).
 Called a shell, because it surrounds the kernel.
 The shell indicates its readiness to accept another command by typing a prompt, and the user types a command
on a single line.
 A typical command is an executable binary object file.
 The shell travel through the search path to find the command file, which is then loaded and executed.
 The directories /bin and /usr/bin are almost always in the search path.
 Typical search path on a BSD system: (./home/prof/avi/bin /usr/local/bin /usr/ucb /bin /usr/bin )
So far, there has been no mention of the user interface for UNIX. UNIX is a good operating system for experienced
programmers. The operating system was designed and implemented by experienced programmers so everything, which
the experienced programmer needs, is present but not much else. A perfect example of this is the on-line documentation
called "man-pages" or manual pages. The material is completely reference oriented with very little tutorial information.
Experienced programmers find the man pages very useful but the beginning user often finds them overwhelming.
In the last few years, there has been extensive work to improve the user interface to UNIX. The most dramatic effort has

been the addition of windowing interfaces on top of UNIX such as X-windows, Suntools, NextStep, Motif, OpenLook, etc.
These windowing interfaces do not change UNIX itself but are built on top of UNIX to provide a more intuitive interface to
UNIX. Each of the different user interfaces has some advantages and some disadvantages. Currently intensive
development effort is being done on all of these Graphical User Interfaces (GUIs).
The User Interface for Chorus is similar to that of Unix.
Process Management
A program in execution is called process in UNIX environment. Under UNIX system any number of process can exist for
a given program. Every process running under UNIX is identified by a process- id (pid), an integer value. Each process
is identified with the owner of the process, simply called uid. Processes are arranged in a tree structure link. So except
the root, all other process is attached with its parent.
Unix is a timesharing system, which means that the processes take turns running. Each turn is a called a timeslice; on
most systems this is set at much less than one second. The reason this turns-taking approach is used is fairness: We
don't want a 2-second job to have to wait for a 5-hour job to finish, which is what would happen if a job had the CPU to
itself until it completed.
A process in Chorus defines a protected address space, which encapsulates the following resources: a set of threads
that share the resources of the process, a virtual memory context, and a set of ports for communication with other
processes. Every process has a protection identifier associated with it. If the process forks, the children inherit the same
ID. Protection identifiers provide a mechanism for authentication.
There are three kinds of processes in Chorus, each having different execution privileges.
 Supervisor processes execute in the same address space as the micro kernel and are permitted to directly
execute kernel instructions. They may also execute privileged I/O instructions.
 System processes are permitted to execute kernel operations but may not execute privileged I/O instructions.
Unlike supervisor processes, system processes execute in a private address space.

 User processes may execute neither kernel operations nor privileged I/O instructions. They run in a private
address space.
Many threads can execute concurrently within a process. Each thread is characterized by the state of the processor. The
scheduling scheme is very flexible: although the basic scheme is priority-based, Chorus also supports time-slicing and
priority degradation on a per-thread basis.
Memory Management
Abstract memory objects are typically provided to protect regions of memory. Virtual memory management may be
implemented as part of the kernel or user-level process.
The Unit of data abstraction in Chorus is called the segment. Segments generally represent some form of secondary
storage such as a file. Similarly to other abstractions in Chorus, segments are global and are identified by capabilities.
Each process address space is divided into regions. A region is a contiguous range of virtual addresses within a
process, which maps a portion of a segment to a given virtual address. Associated with each mapping is a set of access
rights.

System processes known as mappers are responsible for mapping segments onto regions. If a process makes a request
to read or modify data within a region, the mapper returns the appropriate segment containing the data. Segments are
swapped on a demand basis by a user level process called the External Mapper.
UNIX Memory Management
 All memory assigned as pages
 Each user process works in a virtual 4GB memory space
 Multi-User nature of UNIX requires that no memory be allocated to absolute locations
Unix memory management is based on Demand-paged virtual memory system. It employs the Least Recently Used
algorithm.
Each process has a separate virtual address space. This virtual memory is implemented via demand paging. Pages in
physical memory are selected for replacement using a modified working-set policy. A page that has not been referenced
in a certain length of time is considered no longer to be in the working set of any process; thus it becomes a candidate
for replacement. It is possible that the working sets of the processes being run might require more pages than can fit into
memory. If this happens, one or more of the processes is temporarily suspended. Pages being used by these processes
are removed form memory to make more room available.

File System
A file system is a logical method for organizing and storing large amounts of information in a way that makes it easy
manage. The file is the smallest unit in which information is stored. The UNIX file system has several important features.
Types of Files in Unix:

To the user, it appears as though there is only one type of file in UNIX, the file that is used to hold your information. In
fact, the UNIX file system contains several types of file.
 Ordinary files: This type of file is used to store your information, such as some text you have written or an image
you have drawn. This is the type of file that you usually work with.
 Directories: A directory is a file that holds other files and other directories. You can create directories in your home
directory to hold files and other sub-directories.
· Special files: This type of file is used to represent a real physical device such as a printer, tape drive or terminal. It
may seem unusual to think of a physical device as a file, but it allows you to send the output of a command to a device
in the same way that you send it to a file.
· Pipes: UNIX allows you to link commands together using a pipe. The pipe acts a temporary file that only exists to
hold data from one command until another reads it.
Structure of the file system:
The UNIX file system is organized as a hierarchy of directories starting from a single directory called root which is
represented by a / (slash). Imagine it as being similar to the root system of a plant or as an inverted tree structure.
Immediately below the root directory are several system directories that contain information required by the operating
system. The file holding the UNIX kernel is also here.
/(root)
|
--------------------------------------------------------------
| | | | | | | |
/bin /dev /etc /home /lib /tmp /usr kernel file
Chorus Operating System supports the following file systems:
· Unix File System (UFS)
The UNIX file system option provides support for a disk-based file system, that is, the file system resides on physical
media such as hard disks. The UNIX file system option supports drivers for the following types of physical media:
o SCSI disks
o IDE disks

 RAM disks
· MS DOS file system
· Network File System (NFS)
The NFS permits transparent access of remote files on most Unix systems and many non-Unix systems, including
Microsoft Windows. This facility can be used, for instance, to dynamically load applications from the host on the target.
It Includes:
· NFS Client, which gives access to remote files from Chorus.
· NFS Server, which allows to mount local file systems from a remote system.
Applications have access to
· The standard POSIX.1 file I/O interface.
· The ANSI-C stdio(3)
· The BSD file I/O
· The C++ iostream.
Inter-process Communication
IPC is a set of programming interfaces that allow you to create and manage individual program processes that can run
concurrently in an operating system. This allows a program to handle many user requests at the same time.
The various IPC methods are:

 Pipes and named pipes
 Message queuing
 Semaphores
 Shared memory
 Sockets
 RPC
IPC is provided for the following reasons:
 In-order delivery of data - so that the receiving process reads messages in the order that they are sent.
 Unduplicated delivery of data - so that the receiving process only gets each message once.
 Reliable delivery of data - so that no data is lost.
 Preservation of message boundaries - so that individual messages are not mixed up into one.
 Support for out-of band messages - so that "emergency" situations can be handled on the same channel.
 Connection oriented communication - so that a connection can be established between two independent
processes before any other communication takes place.
Communication services provided by Chorus are:
 Asynchronous message passing.
 Synchronous RPC.

Asynchronous Message-passing does not guarantee delivery of message. During asynchronous message transfer no
notification is sent to the sender. Asynchronous message passing reduces network traffic. It has higher performance and
provides better scaling to large or busy networks.
Synchronous RPC is based on the client-server model. It guarantees delivery of message by sending notification to the
sender. It is a simple concept, which is easy to understand. It is easy to handle in case of errors or crashes.
Processes in Unix based systems communicate between themselves through IPC constructs. Among these are:
 Pipes
 FIFO (named pipes)
 Streams (Files)
 Sockets
 Messages: Exchange messages with any process or server.
 Semaphores: Allow unrelated processes to synchronize execution.
 Shared memory: Allow unrelated processes to share memory.

Protection and Security
Security and Protection is provided for the following reasons:
 Secrecy:
Information is accessible for reading by authorized parties only.
 Integrity:
Information is accessible for modification by authorized parties only.
 Availability:
Computer system assets are available to authorized parties only.
Types of security threats are:
 Interruption
Threat to Availability
 Interception
Threat to Secrecy
 Modification
Threat to Integrity
 Fabrication
Threat to Integrity

Security in Chorus is offered in the application level. There is no security in the Chorus nucleus. Chorus has provisions
for the development of secure distributed systems through support for access control and authentication. Security is
offered in Chorus by the concept of unique identifiers. Knowledge of Unique Identifier gives full privileges to manipulate
the object.
The types of security provided in Unix are:
PhysicalSecurity
 Console Security
 Data Security
 Users practice secure measures
 NO welcome banner on site
NetworkSecurity
 Filtering
 Prevent Spoofing
 FTP Security
 Modem Security

AccountSecurity
 Password Security
 Root Accounts
 Guest Accounts
 User Accounts
File SystemSecurity
 NFS Security
 Device Security
 Script Security
 Program Security
 General Security Measures

Case study

More Related Content

What's hot

Similar to Case study

Recently uploaded

Case study