Simple Structure

• MS-DOS was originally designed and implemented by a few people who had no idea that it would become so popular. It was written to provide the most functionality in the least space, so it was not divided into modules carefully. Fig. 2.37 shows its structure.

  Figure 2.37: MS-DOS layer structure.

  
• In MS-DOS, the interfaces and levels of functionality are not well separated.
  • For instance, application programs are able to access the basic I/O routines to write directly to the display and disk drives.
  • Such freedom leaves MS-DOS vulnerable to errant (or malicious) programs, causing entire system crashes when user programs fail.
• Of course, MS-DOS was also limited by the hardware of its era. Because the Intel 8088 for which it was written provides no dual mode and no hardware protection, the designers of MS-DOS had no choice but to leave the base hardware accessible.
• Another example of limited structuring is the original UNIX OS. UNIX is another system that initially was limited by hardware functionality.
• It consists of two separable parts: the kernel and the system programs.
  • The kernel is further separated into a series of interfaces and device drivers, which have been added and expanded over the years as UNIX has evolved.
• We can view the traditional UNIX OS as being layered, as shown in Fig. 2.38. The kernel provides the file system, CPU scheduling, memory management, and other operating-system functions through system calls.

  Figure 2.38: UNIX system structure.

  
• Taken in sum, that is an enormous amount of functionality to be combined into one level. This monolithic structure was difficult to implement and maintain.
• Monolithic systems is the most common organization. The structure is that there is no structure. The OS is written as a collection of procedures, each of which can call any of the other ones whenever it needs to.
• To construct the actual object program of the OS when this approach is used, one first compiles all the individual procedures, or files containing the procedures, and then binds them all together into a single object file using the system linker.
• In terms of information hiding, there is essentially none - every procedure is visible to every other procedure. Even in monolithic systems, however, it is possible to have at least a little structure, remember the system calls.