Introduction of Operating Systems

In today’s technological world there are so many different, new and exciting advances happening every day. But many of us are confused, when it comes to the basic understanding of this new technology. The area people need to start when trying to understand the basics of any computer hardware system would the operating system. Operating systems are a program which manages the computer’s hardware. These systems provide a basis for application programs and intermediate between the computer’s user and its hardware. There are many different types of Operating serves that are available to use. There are four main Operating systems that are used in today’s Technological world: UNIX, Linux, Mac, and Windows. Each one of these systems has its own unique aspects to offer users, while still sharing the same basics that an operating system needs.

Memory Management

UNIX/Linux

In comparison to other operating systems, UNIX is quite different when it comes to managing its memory. It uses extremely sophisticated memory management algorithms to make the best use of memory resources. Though UNIX and Linux are extremely similar when it comes to how things work internally, there are slight differences that make UNIX distinct. One process that UNIX uses is Swapping; this is done by moving chunks of the Virtual Memory, known as pages, out of the main memory and moving others in. In order for this process to work at its best, those pages that are needed must be accessible in the Main Memory at the demand of the CPU. When a page is expected to be needed in the very near future it is called a resident set. This can lead to errors due to memory allocation issues. If the CPU attempts to access a page that is no longer available in the Main Memory, a page fault will occur, and the needed page will then have to be located, as the CPU waits for the swap to occur. The main purpose of the Memory Manager is to minimize the number of page faults that occur. Though the swapping of memory seems like a performance impeding event, it is actually not; when the performance becomes altered it is only due to the occurrence of a page fault.
Another method of Memory Management used by UNIX is called Mapping. Mapping is when a segment of a files virtual memory is designated as corresponding to the contents of the given file. When the mapped file is accessed it is actually pulling data from the file itself. File mapping is primarily used for the loading of executable code or when a program is launched. One of the initial actions after this occurs is to map the program executable and all of its shared libraries into the newly created virtual memory space. There are a few systems that will let you see how this actually works by using trace, truss, or strace depending on which distribution of UNIX or Linux you have. One important thing to note about this method is that mapped files will share the same address space as RAM. The size of these files can be limited if the CPU or Memory controller is only using 32-bit addressing, meaning that files larger than two or three gigabytes can’t be mapped at all. Some older operating systems always make a copy of the mapped file contents into the swap space. This allows room for error when something happens with the Mapped file, because a clean copy exists in the swap space.
Although Linux shares a number of the same characteristics of memory management with other UNIX operating systems but it has a number of its own features that are a part of Linux’s unique implementation of memory management. Linux utilizes virtual memory in its scheme and also kernel memory allocation for the purposes of handling addressing and allocation of memory to specific processes. Specifically, Linux has a three level page-table structure that consists of a number of different types of tables. These three tables are the page directory, page middle directory, and the page table. Each process running in the OS has a single page directory; each entry in the page directory corresponds to a page in the page middle directory and must be in main memory for any active process. The page middle directory can span a number of pages with each pointing to a single page in the page table. The page table also has the capacity to span multiple pages and each entry in the table refers to a virtual page in the process.
Utilization of this three level page table structure depends on the use of virtual memory; a virtual memory address is made up of four fields. The leftmost field serves as an index into the page directory; the next field is the index for the page middle directory while the third is an index in the page table. The fourth and final field in the virtual memory address provides the offset within the selected page of memory.
The primary benefit of this type of virtual memory addressing is that it is platform independent. This type of addressing is also specifically optimized for 64 bit Alpha processors which support this three level paging structure. Pentium x86 processors on the other hand run on 32 bit architecture and only support two levels of paging, Linux can accommodate a two level paging structure however by changing how the page middle directory’s size is defined. References to the three page structure are optimized out in systems that use only two levels of paging.
In Linux page allocation is used to further optimize how memory is addressed. Page allocation is a system that groups blocks of pages into larger contiguous blocks of page frames. The kernel maintains a list of page frame groups of a fixed size up to 32 frames. Groups can then later be split when being allocated and de-allocated in main memory. Linux also uses a page replacement algorithm, periodically the algorithm looks through the page pool and looks for the most likely candidate for replacement. Essentially, the most likely candidate for replacement is generally the page that has been least used by any process.

Mac
According to "Memory Usage Performance Guidelines: About The Virtual Memory System" (2010), “The Mac OS X includes a fully-integrated Virtual Memory System, which provides up to 4 gigabytes of addressable spaces per 32-bit process, or 18 Exabyte’s of addressable space per 64- bit process. The OS X also supports a backing store (is a disk-based repository containing a copy of the memory pages used by a given process).
The kernel associates a VM object with each region of the logical address space. The logical address space of a process consists of mapped regions of memory. Each mapped memory region contains a known number of virtual memory pages. A region can map to part of the backing store or to a memory-mapped file in the file system. Wired memory (also called resident memory) stores kernel code and data structures that must never be paged out to disk.

Page List in the Kernel - the kernel maintains and queries three system-wide lists of physical memory pages:
• The active list
• The inactive list
• The free list
In OS X, if an inactive page contains data that has not been written to the backing store recently, its contents must be paged out to disk before it can be placed on the free list. If an inactive page has not been modified and is not permanently resident, it is stolen and added to the free list. Once the free list size exceeds the target threshold, the pager rests.
Paging Out Process - In OS X, when the number of pages in the free list dips below a computed threshold, the kernel reclaims physical pages for the free list by swapping inactive pages out of memory, the kernel iterates all resident pages in the active Paging in Process and inactive lists.
The final phase of virtual memory management moves pages into physical memory, either from the backing store or from the file containing the page data. A memory access fault initiates the page-in process. A memory access fault occurs when code tries to access data at a virtual address that is not mapped to physical memory. There are two kinds of faults:
• For soft faults, the kernel maps the physical memory containing the pages to the virtual address space of the process.
• For hard faults, the VM object’s pager finds the page in the backing store or from the file on disk, depending on the type of pager (Apple Developer, 2010).
Windows
Windows Memory Management is controlled by virtual memory managers and pages. “The Windows virtual memory manager controls how memory is allocated and how paging is performed. The memory manager is designed to operate over a variety of platforms and to use page sizes ranging from 4 Kbytes to 64 Kbytes” (Stallings, 386). Windows run on 32-bit and 64-bit platforms.
The way Windows memory management systems works is on “pages”. This memory management system has both a physical and virtual memory. The memory is managed in these pages as the processes are being executed. There are three types of regions of space or memory that the operating system can manage. These three are available, reserved and committed. An available region is one where the address of the process is not being used. A reserved region is where the space is not available for any other use and is waiting for a process. Lastly, a committed region of space is pages that have been stored either in physical or virtual memory. The committed region has allowed the process to access the virtual memory pages or at that time can be stored onto disks. According to “Microsoft” (2012), “With each release of Windows memory management supports many new features and capabilities. Advances in algorithms and techniques yield a rich and sophisticated code base, which is maintained as a single code base for all platforms and SKUs” (para. 2).

Process Management

UNIX/Linux

In a UNIX environment programs are run as if no other program is running on the machine at that time. Once a program is launched on a UNIX system, the system then creates a special environment for it including everything needed to run the program. This means that each time a command is issued to the OS a new process is created. The processes are tracked by using a unique five digit ID number known as a PID or process ID assigned to each process. Process ID numbers can eventually repeat but duplicate PIDs cannot exist concurrently, processes can further be divided into two distinct groups; foreground and background. All processes are initially loaded as a foreground process which is initiated by issuing a command to execute; once it is done the output is displayed on the screen. Background processes can basically be defined as processes that are not actively initiated by a command by the user. However, if input is needed the process halts until a response is keyed. Background processes are essentially the same as foreground processes but multiple instances can be executed at the same time.
Linux uses a task_struct data structure for the purposes of managing process execution and management, this data structure contains information for a few different categories. The task_struct structure contains the task state, scheduling information, identifiers, values to facilitate interprocess communication, links between parent and child processes, timestamps and timers, pointers to files used by a process, the virtual address space assigned to a process, the processor specific context of the task, a running status, whether the process is interruptible or uninterruptible, a status to indicate the task is stopped, and a “zombie” status indicator for the task/process.
Traditional UNIX systems support only a single kernel-level thread of execution per process. Similarly, early Linux systems supported only single-threading and required that several user level threads be created and then grouped into a single kernel-level process for execution. Modern Linux systems do however support multi-threading and achieves this in a somewhat unique way.
Linux systems do not recognize a difference between processes and threads; additionally Linux can group multiple user level threads into a single user-level process. These user level processes are then mapped into kernel-level processes which share the same group ID. Processes grouped in this way can share resources among themselves such as files and memory.
Linux uses a clone () command to create new processes, this command basically copies an existing process. When a context switch is done, the Linux kernel checks the page directory of the new process to see if the address of the page directory of an existing process is the same as the newly created process. If these two match then these two processes are considered to be sharing the same address space, so switching context is essentially no more complex than switching between sections of code. However, while two processes can share resources they cannot share user stacks. The clone () call essentially creates a separate user stack space for each distinct process.

Mac
Being a UNIX-like system, a multi-core and multi-processor execution is supported and a programming API called Grand Central Dispatch is provided in MAC OS X GCD, which provides a pool of available threads. The OS will provide as much concurrency as possible based on the number of cores available and the thread capacity of the system. Designers can designate portions of applications, called blocks that can be dispatched independently and run concurrently.
A block is a simple extension to C or other languages, such as C++. The purpose of defining a block is to define a self-contained unit of work, including code plus data. Blocks enable the programmer to encapsulate complex functions, together with their arguments and data, so that they can easily be referenced and passed around in a program, much like a variable.
Blocks are scheduled and dispatched by the means of queues and they are put onto a queue as they are encountered during a program execution. GCD then uses those queues to describe concurrency, serialization, and callbacks. Depending on the queue and how it is defined, GCD either treats these blocks as potentially concurrent activities, or treats them as serial activities.
Thread pools are automatically sized by the system to maximize the performance of the application’s using GCD while minimizing the number of idle or competing threads. In addition to scheduling blocks directly, the application can associate a single block and queues with an event source, such as a timer, network socket, or a file descriptor. This directs the OS to put the following block of code at the end of the main queue, to be executed when it reaches the head of the queue. So, with very little work on the part of the programmer, the desired requirement is met (Stallings, 2012).

Windows
In Windows, processes will always contain one or more threads, and all of the threads are treated equally. Threads allow parallel processing to happen in a single process. There will never be a parent/child type hierarchical relationship with threads in the Windows OS. A thread is also interruptible so the processor can multitask and run other threads. These threads are scheduled based on the following factors: availability of resources, memory, priority, and fairness. Symmetric Multiprocessing (SMP), let’s all the threads be split up between the different processor in the Windows OS.
In the Windows environment, processes are managed by and have the following characteristics (Stallings, 2012):
• Windows processes are implemented as objects.
• A process can be created as new process, or as a copy of an existing process.
• An executable process may contain one or more threads.
• Both process and thread objects have built-in synchronization capabilities.
When a user is logged into their Windows OS, the user is given an access token. The access token is then tagged to all of the processes that the user is executing. This access token also verifies what the user can and cannot do. “The access token controls whether the process can change its own attributes. In this case, the process does not have a handle opened to its access token. If the process attempts to open such a handle, the security system determines whether this is permitted and therefore whether the process may change its own attributes” (Stallings, 2012). The process must also depend on the virtual memory manager to modify any of its structures.

File Management

UNIX/Linux
In UNIX and Linux, all data is organized into files. These operating systems manage files by dividing them into groups, ordinary files, directories, and special files.
Ordinary Files: Ordinary files are files containing data, text, or program instructions.
Directories: Directories are files that contain both ordinary and special files and can be considered roughly equivalent to folders in the Windows and Mac operating systems.
Special Files: Special files are used to provide access to hardware like hard drives or CD Rom drives. Additionally special files can also be used to provide access to a file using links. All files located in your UNIX and Linux systems are classified as private files, unless otherwise indicated by a user’s request. Permissions are an essential part of any File Management System.
When it comes to UNIX and Linux, each file is designated with permissions on what each person accessing the file can do with it. There are ID’s established with each individual user account as well as unique ID’s established with each Group. Groups and Individual users are assigned permissions on the file as such; Read, Write and Execute. The attribute Read allows the person accessing the file to be able to view the file list and open the files, however they are not able to modify, delete or rename the file. If the attribute Write is given, the file can be opened, read, modified, deleted or renamed. The attribute Execute is used for programs and shell scripts, to have it on a directory would allow you to list the files located inside that directory.
Another method for permissions control that is utilized by UNIX and Linux and is much more effective and more configurable is Access Control Lists. This scheme gives the administrators the ability to place specific users and groups on the access list, based on their unique ID. Each and every situation can call for a variety of different methods of configuring security so it is advisable to have the most customizable, yet secure, permissions system to ensure high levels of security.

Mac
The MAC OS X File system is based on UNIX FreeBSD 5.0 in which six types of files are distinguished:
• Regular or ordinary
• Directory
• Special
• Named pipes
• Links

An inode (index node) is a control structure that contains the key information needed by the OS for a particular file. Although, all types of UNIX files are administered by the OS by means of inodes, the exact inode structure varies from one INIX implementation to another. The block size of the data blocks referenced by the inode (typically the same as, but sometimes larger than, the file system block size)
File Allocation

File allocation is done on a block basis. Allocation is dynamic, as needed, rather than using preallocation. An indexed method is used to keep track of each file, with part of the index stored in the inode for this file. The FreeBSD inode includes 120 bytes of address information that is organized as fifteen 64-bit addresses, or pointers. The total number of data blocks in a file depends on the capacity of the fixed-size blocks in the system. In FreeBSD, the minimum block size is 4 Kbytes, and each block can hold a total of 512 block addresses, the maximum size of a file with this block size is over 500 GB.
Access Control Lists in UNIX FreeBSD
The FreeBSD feature is referred to as extended access control list, while the traditional UNIX approach is referred to as minimal access control list. FreeBSD allows the administrator to assign a list of UNIX user IDs and groups to a file by using the setfacl command. Any number of users and groups can be associated with a file, each with three protection bits (read, write, execute), offering a flexible mechanism for assigning access rights, and FreeBSD files include an additional protection bit that indicates whether the file has an extended ACL. When a process requests access to a file system, two steps are performed:

1. First step selects the ACL entry that most closely matches the requesting process. The ACL entries are looked at in the following order: owner, named users, (owning or named) groups, and others. Only a single entry determines access.

2. The second step checks if the matching entry contains sufficient permissions. A process can be a member in more than one group; so more than one group entry can match. If any of these matching group entries contain the requested permissions, one that contains the requested permissions is picked. If none of the matching group entries contains the requested permissions, access will be denied no matter which entry is picked (Stallings, 2012).

Windows
Windows file management is also known as the New Technology File System (NTFS). Its whole intent is to cater to “high-end applications” and servers to organize the data on the hard drives. The NTFS is deemed a simple file system. There are features of this file system that are very important.
• Recoverability
• Security
• Large Disk & Large Files
• Multiple Data Streams
• Journaling
• Compression
• Encryption
• Security
Recoverability is an important requirement because should there be any system and/or disk failures, the NTFS will be able to recover and reconstruct the files to a stable state. Security on the Windows OS uses a security descriptor that will list all of the security attributes and protects each file on the hard drive. The Windows NTFS supports large disks and large files better than most operating systems. Multiple data streams allows for there to be two data streams with a single file on the Windows OS. Journaling is simply a way that the Windows files management system keeps track of all of the changes that are constantly being made. Files can be compressed and encrypted. The security on the Windows file system can be set up encryption and only allow of certain files access to certain users.
Security

UNIX/Linux

One of the obvious benefits of a UNIX system as well as a Mac is that they are immune to Windows based viruses. However at the same time there are many UNIX based systems that work in Windows environments such as Mail Transfer Agents, which means that they could serve as a repository for viruses stored by users. So despite the lack of viruses able to actually be infesting UNIX systems, there are open source programs available that can help scan these programs in order to get rid of the viruses. Security is always a big issue with the wide open world we live in where sharing is everything, and the need to have files sent across the world is almost a necessity. UNIX like every other operating system is no different when it comes to securing its system and its files.
Linux is widely considered to be one of the most secure operating systems available. This runs counter to some conventional wisdom including the idea of “security by obscurity” that because proprietary and closed source systems allow users no access to the OS source code that they are somehow safer from malicious code ("Why Linux Is More Secure than Windows | Pc World", 2012). However, there are a few key concepts that illustrate why Linux has a superior security scheme than Windows operating systems.
When creating user accounts in Windows they are generally given higher level permissions and as such have more access to vital parts of the system. In Linux this is reversed, users are created with low level permissions and have to be granted additional capabilities. What this means in the most basic sense is that if a virus compromises a Linux system it does not have a great deal of permissions with which it can perform malicious activities. Basically it means that only the user who introduced the virus will be affected rather than the entirety of the system.
Windows OS also suffers from the fact that Windows operates in a very standardized fashion and usually on generic hardware. Meanwhile, Linux has a plethora of different options when it comes to distributions, package management, even the shell used to handle issuing commands to and managing aspects of the OS can be customized in Linux. Windows’ monoculture means that a virus can be aimed directly at the Windows operating system and affect a plurality of users of the OS.
Linux has an open kernel and is widely contributed to by all kinds of different programmers. This means that vulnerabilities are easily identified and fixed before ever reaching a point that they are so problematic they become crippling. This plays specifically into what is known as “Linus’ Law”, so named for Linus Torvalds the creator of the Linux operating system. The law states “given enough eyeballs, all bugs are shallow” ("Why Linux Is More Secure than Windows | Pc World", 2012). By using the theory that the user-base is the best development team available, Linux achieves great security while avoiding the pitfalls set by some other Operating systems.

Mac
MAC OS X provides runtime protection for data such as stack canaries, heap corruption checks, and sandboxed system services to help stymie attacks that try to hijack or modify system software (Webinos, 2012).
Unlike traditional UNIX systems, “MAC OS X disables the root account by default. Running code with the minimum necessary level of privileges helps protect the system from inadvertent or deliberate damage, as well as limit the extent of harmful changes that viruses or unauthorized users could make to the OS” (Webinos, 2012)
In a networked environment MAC OS X can provide authentication using UNIX Pluggable Authentication Modules, Open Directory, Active Directory, Kerberos and NTLMv2. Other security features include:
• File Vault – is a security feature that uses encrypted file systems that are mounted and unmounted when the user logs into or out of the system.
• Keychain – is an integrated password management system, it can contain various types of data: passwords (for Websites, FTP Servers, SSH Accounts, Network Shares, Wireless Networks, Groupware Applications, and Encrypted Disk Images), private keys, certificates and secure notes.
• The Application-Based Firewall – allows or blocks incoming connections on a per-application basis rather than on a per-port basis.
• The Kernel - provides mandatory access controls, which are integrated with the exec system service to prevent the execution of applications that aren’t authorized.
In the case of the Sandboxing Facility, mandatory access controls restrict access to system resources as determined by a special sandboxing profile that is provided for each sandboxed application. This means even processes running as root can have extremely limited access to system resources (Webinos, 2012).

Windows
As mentioned before in regards to process management, Windows uses an access control scheme to validate with user and the users actions. Once the user logs on to the Windows system, if the user name and password are accepted, the user receives an internal access token. This token is connected to everything the user will be doing. For every process that the user executes that particular access token is associated with those processes. The access token serves two purposes according to Stallings (page, 668):
1. It keeps all necessary security information together to speed access validation. When any process associated with a user attempts access, the security subsystem can make use of the token associated with that process to determine the user’s access privileges.
2. It allows each process to modify its security characteristics in limited ways without affecting other processes running on behalf of the user.
There are 5 different types of access tokens. They are Security ID, Group SIDS, Privileges, Default Owner and Default ACL (Access Control List). The parameters of the Security descriptor are Flags, Owner, System access control list, and discretionary access control list.

Conclusion
With all of the new operating systems technology it is difficult to understand the differences between them all. Each operating system is unique in its own and special way. The four main Operating systems that are used in today’s Technological world are UNIX/Linux, Mac, and Windows. There really is no better operating system when comparing them. The only thing that makes a difference in what operating system is being used, would be the user themselves and what they are specifically using the operating system for, because each one of these systems offers stronger aspects in certain areas than the others. References
Apple Developer. (2010). Memory Usage Performance Guidelines: About the Virtual Memory System. Retrieved from http://developer.apple.com/library/Mac/#documentation/Performance/Conceptual/ManagingMemory?Articles/AboutMemory.html
Debian WIKI. (2011). Permissions - Debian Wiki. Retrieved from http://wiki.debian.org/Permissions#Access_Control_Lists_in_Linux
IBM. (2012). Learn Linux, 101: Manage File Permissions and Ownership. Retrieved from http://www.ibm.com/developerworks/linux/library/l-lpic1-v3-104-5/index.html
Microsoft. (2012). Retrieved from http://msdn.microsoft.com/en-us/library/windows/hardware/gg463005.aspx
PC World. (2012). Why Linux is More Secure than Windows. Retrieved from http://www.pcworld.com/article/202452/why_linux_is_more_secure_than_windows.html
Stallings, W. (2012). Operating Systems: Internals and Design Principles. Upper Saddle River, NJ: Prentice Hall.
Tutorials Point. (2012). UNIX - File Management. Retrieved from http://www.tutorialspoint.com/unix/unix-file-management.htm
Webinos. (2012). Mac OS-X. Retrieved from
http://webinos.org/deliverable-d026-target-platform-requirements-and-ipr/2-6-mac-os-x-ntua/