Introduction The most commonly known Operating Systems (OS) today are UNIX, Linux, MacOS, and Windows. These operating systems all behave in their own way and similar in others. This paper will discuss this comparison of how these operating systems utilize memory, process handling, file management, and security.
Memory Management Each operating system is required to allocate a certain amount of memory for the operating system itself for the processes that are being used or executed. There are two places memory exists: physically on the motherboard of the computer and within the operating system itself. When the operating system dynamically divides the memory usage between these two areas, this is called memory management. Each operating system manages memory different from the others; however they all follow some basic rules of memory management. All of the operating system’s memory management in general follows these requirements: relocation, protection, sharing, logical organization, and physical organization (Stallings, 2015). Relocation of memory is the process that allows the operating system to move a process or file from physical memory to virtual memory and back again, depending on the need for that data. Virtual memory exists within the operating system which uses the hard drive to store temporary information and physical memory is located on the motherboard of the computer. While the process is in memory, protection of that area needs to be enabled to block interference from unwanted sources. This protection is usually written in the code to execute the process, and to only allow a certain amount of memory to be used for this particular process. This protection will prevent a particular process from being used by another process in memory. Each process uses only what it needs while in memory and memory management of the operating system upholds this allocation by placing it in correct memory space. However, there may be a need to allow other programs to access a process that is used by more than one program. Sharing allows for the same memory space to be accessed versus creating another memory space to put a copy of the process in. Organization of the memory is the final piece that ties memory management together. Logical organization allows for main memory and secondary memory to be organized in a linear fashion. When a programmer writes the code for a program with this logical organization in mind, they write in modules. These modules can be written and placed in memory, allowing the system to utilize and share the memory if written. Physical organization splits main memory from secondary memory, placing emphasis on main memory being used first. This could create problems if the main memory is already used. The system would need to swap out main memory to put in secondary memory, then allow the program that needs main memory to run. This can slow things down a bit, but offers high priority to programs that request it.
Memory Comparison According to Data Expedition, Inc. (2015) UNIX has three kinds of memory: main, file system, and swap space. The main memory is located on the motherboard, also known as RAM or real memory. The file system memory is located on the disk and holds all of the pathname information. The swap space is an allocation of disk space which is not for real memory or the file system. It exists as a large file to swap memory space when needed. The UNIX kernel is held in main memory, cache is stored in file system memory, and virtual memory can be split throughout all three kinds of memory. According to an article on thegeekstuff.com (2012) Linux is driven by virtual memory. Linux’s memory is configured in such a way that all memory is grouped together and appears larger than the physical memory on the motherboard. When a program is put in to memory space, the Linux kernel uses a page table to define where the program should use the physical memory address, thus assigning the virtual memory to physical memory. When the program is finished, it releases the virtual memory, and then the page table clears the entry to the physical address. Much like Linux, Mac and Windows utilizes virtual memory to manage memory usage. In OS X, the “system provides up to 4 gigabytes (GB) of addressable space per 32-bit process.” (Apple, 2013)
In Mac OS X, there are uniform sized address spaces littered throughout all of the memory which are called pages. The kernel resides in wired memory, otherwise known as resident memory, which cannot be tampered with. However, the active pages are address spaces that have been used recently and are currently mapped. Inactive pages are address spaces that are currently in memory, but have not been recently accessed allowing for them to be removed at any time. Finally, the free list are pages that do not have any address space allocated and are essentially free space to be used. In Windows, 2 GB of virtual address space is allocated to each process and is known as the private address space. Another 2 GB is allocated for shared processes and the operating system, which is known as the public address space. (Microsoft, 2010) Even if the Windows computer does not have 4 GB of RAM, the system still provides 4 GB of virtual address space. In Windows translation tables are used to provide the system with virtual to physical address locations. If a program uses more physical address space than what is installed, the system will create page files that are located on the hard disk which act like a swap file in UNIX. This allows for the program to use address space even if the RAM is not there to support it.
Process Management This section will cover process management and how it compares and contrasts between UNIX, Linux, Mac OS, and Windows OS operating systems. According to Stallings (2015), “a process consists of program code and associated data plus a process control block.” (p. 108)
The UNIX operating system has the simple process implementation, with the only process categories being "system" and "user" (Stallings, 2015, p. 142). According to Stallings (2015), there are nine process states: "with the three most important being Ready, Running, and Blocked.” (p.147) The UNIX system data structures are the managers of the processes. The three context levels are user-level, register-level and system-level (Stallings, 2015, p. 144).
In the Linux operating system, processes are identified by a defined structure: “task_struct" (Stallings, 2015, p. 182). According to Stallings (2015), the categories of these structures are "state, scheduling information, identifiers, inter-process communication, links, times and timers, file system, address space, processor-specific context, running, interruptible, stopped and zombie (p. 182-4). Older versions of Linux employed single threading. Newer versions do not have multithreading, but have a system instead that does not differentiate between threads and processes. Instead, processes are cloned which allows them to share resources without extra overhead for the scheduler to switch between grouped processes, but each cloned process will have separate stack space (Stallings, 2015, p. 184-5). Additionally, Linux uses namespace associations to indicate what parts of the system are visible to a process. According to Stallings (2015), the current namespaces are "mnt, pid, net, ipc, uts, and user” (p. 185).
Like other operating systems, the Mac OS X has its version of handling process control via a pool of threads, the Grand Central Dispatch (GCD) (Stallings, 2015). According to Stallings (2015):
“Designers can designate portions of applications, called blocks that can be dispatched independently and run concurrently. The OS will provide as much concurrency as possible based on the number of cores available and the thread capacity of the system. Although other operating systems have implemented thread pools, GCD provides a qualitative improvement in ease of use and efficiency” (p. 190).
A block includes all code and data to perform a function making it easily referenced throughout a program (Stallings, 2015, p. 191). The GCD uses queues for its scheduling system. Queues may be handled either as "single queue multiple server” where the processor handles a job as it arrives – like airline check-in lines, or “multiple queue multiple server” – which are more like supermarket checkouts (Stout, 2015). Functions are easy to develop in GCD because of a standardized pattern for executing code in the main thread. According to Stallings (2015) “The first line of the function body analyzes the document, the second line updates the application’s internal state, and the third line tells the application that the statistics view needs to be updated to reflect this new state” (p. 192). Nomenclature for GCD requires functions to being “dispatch_” with the variation “dispatch_async” signaling the OS that the block may be executed in a parallel queue.
The Windows operating systems uses an object-oriented approach to it process management. A Windows process becomes an object with an access token that includes the user's security ID. As the process object interacts with other objects, this token informs the process know if it can change attributes for itself or the other object, or if the other object can change attributes of the original object (Stallings, 2015, p. 173). If a process can be broken down into smaller executable tasks (threads), each thread may become a process. Each of these thread objects may run concurrently and in parallel across a processor allowing a process to be run using many processors. The result is faster and very efficient processing, especially in server applications (Stallings, 2015, p. 176). Where the Windows OS is very similar to the others is with its process states. Even though the different systems have different names, the basic concepts are the same. The states for Windows operation systems are ready, runnable (ready), zombied, waiting (blocked) and stopped (Hughes & Hughes, 2008, pp. 111-112).
File Management Windows Operating systems allow user file management through “My Computer”. File management enables users the right to create folders, move folders, delete, change, and copy. There are many options for users to control their data either through a single folder or several folders. You can use the search bar to locate specific files quicker, or you might find it easier to place folders on the desktop for faster access.
Linux Operating system file management provides users with a file manager application that allow users to create, access, and manage all files on their system. The traditional way of data management for Linux is through the command line.
UNIX Operating system file management organizes all user files in directories and sub-directories into a tree-like structure called the file system. Users have the ability to create, remove files, copy and rename all files.
Mac OS file management has various ways to manage user data. Data management can be completed through smart folders, super filing, quicksilver, and Pop-Up folders. Smart folders are a great way to organize/manage data. The folders are located in the library under the quick searches under the user profile. Super filing puts all files into a single folder, and you can use the spotlight to locate specific files. Quick Silver this is used quickly to access the most common used files and folders. “QuickSilver can also be used to store links to files and folders. Last Pop-Up folders, this allows any folder to be turned into a navigable pop-up menu like a folder on the right side of the dock, except it appears wherever the cursor is” (Manage files in OS X Your Way, 2009).
OS Security Differences
When looking at systems like Mac OS, Windows 7, Linux and UNIX, there are some different architectures and system designs. As a result there are some differences in how each of these systems handle system security within the file system as well as access control.
Linux / UNIX file system security ‘requires’ an owner of every file, either an actual user, or root (admin). Daemons (services) also run as a user as well. The file system recognizes the ‘owner’, a group (single one only), and ‘other’ – which is access requested by anyone other than the owning user/group. If the system allows anonymous or guest login, the ‘other’ also includes those guests. ‘Other’ is not needed for web access, as the files are actually read by the user the web service runs as (user apache for example), so the ‘owner’ of files in the web directory would typically be ‘apache’.
Access to files is granted in terms of owner, group, and other, as previously mentioned and in terms of granting, or specifically denying, read, write, and execute. Linux/UNIX varies from MS-style operating system in that just because you can ‘read’ a file, doesn’t mean you can execute it. Because of this Linux/UNIX are fairly resilient to viruses. As an example, downloading a binary (executable) file, and it stores to the /home/’user’/download folder. Even though it is a binary (compiled) program, like an .EXE in Windows, it will inherit the default privileges for the /home/’user’/download folder. Typically that will be something like +R, +W, and –E. A significant difference between Linux/UNIX file system security, and a MS style one, is that only 1 user and 1 group can be granted access to a file or directory. In Windows, you can click on the Security tab for a file or directory and add however many users you want to. With Linux/UNIX, you cannot do that, to grant access to a group of users, the sys admin would have to create a group containing specifically those users. Multiple file management methods exist in Linux/UNIX. The default method is the flat file system, the /etc/passwd file. This contains the userid or groupid number, the user/group name, and a hash of their password. It also includes a pointer to their home directory on some systems. The user puts in a username & pass, and the system checks the /etc/passwd file for the username & password. If it matches, it grants access.
Samba is a Windows-like authentication system that can actually fool Microsoft and be a member server in a Window domain or active directory. You then configure shares in the /etc/smb.conf file and the server throws it out there to the Windows client world. FTP – self-explanatory, but typically is built to use the default authentication system for the server, so unlike Windows where you have to create FTP accounts for the FTP service separate of the user accounts on the server, if you have a user account on the Linux box, you can ftp into it just fine. SSH – Secure Shell / encrypted. Not dramatically different from local console access, other than one Linux machine, say if you are logged in locally to Linux1, and you SSH to Linux2 – if you have previously logged in there with SSH, it will have a copy of your SSL certificate, and vice-versa. If that changes, it will challenge you again.
Mac OSX, being based on BSD UNIX, is more or less identical in many ways. Exceptions are that the file system access is not as rigid, it is not case-sensitive for example, and there is a GUI wrapped around all functions, however, open a terminal window, and all of it is still there.
Conclusion
Operating systems are binding between the user and the hardware. The different operating systems are configured to have the same general purpose, yet hold their place as separate systems from each other. Some are used for different purposes based on what the user needs and the purpose the computer will have. It is important to know the different aspects between UNIX, Linux, Mac OS, and Windows and how memory management, process management, file structure, and security all work together on those systems. Each Operating System has its own file management tools/functions. File management similar in different Operating systems because the properties of the function allow the same actions to take place for the most part. Users have the ability to at least, create, delete, move, and copy files inside their profiles no matter the Operating System that is being used by the user. References
Apple. (2013). Mac Developer Library. Retrieved from https://developer.apple.com/library/mac/documentation/Performance/Conceptual/Managi ngMemory/Articles/AboutMemory.html
Arora, H. (2012). The Geek Stuff. Retrieved from http://www.thegeekstuff.com/2012/02/linux-memory-management/
Data Expedition, Inc . . . (2015). Memory Management. Retrieved from http://tips.dataexpedition.com/memory.html
File Managers for Linux. (2005). File Managers for Linux. Retrieved from https://www.linux.com/news/software/applications/8102-file-managers-for-linux
File Manager (Windows). (2015). File Manager (Windows). Retrieved from http://en.wikipedia.org/wiki/File_Manager_ (Windows) 2015
Hughes, C. & Hughes, T. (2008). Professional multicore programming: design and implementation for C++ developers. Retrieved from http://www.ebrary.com.
Introduction to UNIX. (N.D.). Introduction to UNIX. Retrieved from http://www.le.ac.uk/oerresources/bdra/unix/page_34.htm
Manage files in OS X Your Way (2009). Manage files in OS X Your Way. Retrieved from http://www.macworld.com/article/1140847/customizeosxmanagefiles.html
Microsoft. (2010). RAM, virtual memory, pagefile, and memory management in Windows. (2010). Retrieved from http://support.microsoft.com/en-us/kb/2160852
Stout, Q. (2015). What is parallel computing? A not too serious explanation... Retrieved from http://web.eecs.umich.edu/~qstout/parallel.html
University of Phoenix. (2015). Operating Systems: Internals and Design Principles. Retrieved from University of Phoenix, POS355 website.