The Key Points and Elements in the Cent 6.4 Operative System

Categories: Computer Software

An Analysis of CentOS 6.4

Have you ever looked for an operating system while on a budget that you can trust to be stable, secure, low-maintenance, and reliable. If so CentOS is a great choice because it is a rebuild of Red Hat Enterprise Linux, an enterprise class operating system. In theory, CentOS should match Red Hat right down to any bugs not yet addressed. In this essay, I will cover the major design principles, overview major elements and components while simultaneously covering different methods used, and point out the advantages and disadvantages of CentOS.

Design Principles

CentOS is a rebuild of Red Hat Linux’s source, a enterprise Linux distribution. The CentOS team removes Red Hat’s branding and artwork, then compiles their source and distributes the OS for free. This means that an Enterprise-class OS is available to anyone. This is not an OS that has the most up to date packages possible, but instead aims to be an enterprise class operating systems.

Get quality help now
Verified writer

Proficient in: Computer Software

4.7 (348)

“ Amazing as always, gave her a week to finish a big assignment and came through way ahead of time. ”

+84 relevant experts are online
Hire writer

Its goals are to be stable, secure, low-maintenance and reliable with each version supported for up to 10 years by means of security updates (FrontPage, 2013). CentOS is a multi-user, general purpose server and desktop OS and as such, it is a time sharing centric OS. This does not mean it lacks batch capabilities. Once the respective packages are installed, batch services are maintained by two services: at and batch. “The at command is used to schedule a one-time task at a specific time and the batch command is used to schedule a one-time task to be executed when the systems load average drops below 0.

Get to Know The Price Estimate For Your Paper
Number of pages
Email Invalid email

By clicking “Check Writers’ Offers”, you agree to our terms of service and privacy policy. We’ll occasionally send you promo and account related email

"You must agree to out terms of services and privacy policy"
Check writers' offers

You won’t be charged yet!

8” (At and Batch, n.d.). CentOS does not support a real time scheduler out of the box but the operating system community has created a patch that many users have deployed.

Process Management

CentOS 6.4 uses the linux kernel 2.6.32-358. Because this kernel is open source much is known about it. For example each process is represented by a C structure known as a process control block, or PCB. Each processes’s PCB contain’s the information such as the process state, scheduling information, the process’s parent, the processes children, any open files and the address space of the process (Silberschatz, Galvin & Gagne, 2013, p. 110). Another piece of information the PCB contains is a process identifier, or PID. Most operating systems use these to help identify processes. In linux the PID is a unique positive integer. A root parent process identifier (ppid) has a reserved id of one and is called init. In linux its easy construct a tree created by PIDs and corresponding PPIDs all the way to the root, init, with the command “ps -el” (Silberschatz et al., 2013, p. 116).

The linux kernel 2.6.32-358 is a fully pre-emptive kernel. A pre-emptive kernel is one that allows a process to be interrupted. This has many advantages but also increases complexity. One of these additional complexities is that the kernel must support a way to synchronize processes. Synchronization is a way to prevent problems such as race conditions. It does this by providing a way for an algorithm to know when it is safe to enter a its critical-section (Silberschatz et al., 2013, p. 234). The linux kernel provides many methods for synchronization but the simplest is an atomic integer represented using the data type atomc_t. Performing simple operations such on this integer are preformed without interruption but it’s usefulness is limited. If multiple variables must be used more sophisticated tools such as mutex locks, spinlocks, and semaphores must be used (Silberschatz et al., 2013, p.234).

Interprocess Communication

CentOS and the Linux kernel provide many ways for processes to communicate, facilitating cooperations. This allows information sharing, computational speedup (by breaking tasks into subtasts that can be executed in parallel), modularity and convenience. For example, in CentOS the command “Is more” will pipe the standard output of ls, a directory listing, into the standard input of more, a program that displays output one page at a time. A second way processes in CentOS can communicate is though shared memory. Shared memory allows two processes to have access to the same memory segment. Because there is no intermediation once the address space is set up this is by far the fasted form of interprocess communication since there is no intermediation. (Goldt, 1995) CentOS has implemented the standardized system cal mmap() which allows files to be mapped into memory (Love, 2007).

Mapping files into memory can also be useful for various reasons but when the same file is mapped by multiple processes it allows for interprocess communication (Silberschatz et al., 2013, p. 432). When used for interprocess commutation memory-mapped files act very similarly to shared memory except that the contents of the memory will be saved back to disk once all processes release the memory mapped file. In addition to processes on the same system communicating, processes on different system may also need communication methods. One such methods is though the use of sockets. Sockets are endpoints in a common, efficient and low-level form of communication over a network. They allow an unstructured stream of bytes between processes (Silberschatz et al., 2013, p. 138). CentOS also supports higher-level and more structured communication methods processes on separate systems can use.

One of these higher-level methods is called Remote Procedural Call or RPC. RPCs are a level of abstraction, hiding the details of the two systems communicating. They allow for one system to call a procedure on a second system just as if the the procedure was located on the first system.

Memory Management

As with other operating systems, memory management is an integral and important part of CentOS. The linux kernel’s memory subsystem provides functionality such as making the amount of memory appear larger then it really is though the use of virtual memory. To make the translation between virtual and physical memory easier, each system is divided into pages that can be switched back and forth (Rusling, 1999). In linux this process has its performance improved by using demand paging. When demand paging is in use and a process is loaded only the pages being currently used are moved back to physical memory. If memory that is still stored on disk is required a page faults will be generated, that page will be moved back to physical memory, then the process will restart the command that generated the page fault. Virtual memory does have issues that must be addressed.

One such issue is thrashing, or a process spending more time paging then executing. As more processes are added to a system and the amount of needed paging increases. The CPU scheduler will then detect decreased CPU utilization and further increase the number of processes, compounding the problem. Unfortunately, CentOS’s does not have a solution to this problem, simply stating the amount of RAM for a system experiencing this problem is insufficient (Physical and Virtual Memory, 2005). Every process in CentOS has it’s own address space unless additional shared memory has been requested. This address space is protected by the linux kernel from other processes. The kernel also helps prevents the current process from accessing other process’s address space. “This protects code and data from being overwritten by rogue applications” (Rusling, 1999).

The kernel is also responsible for memory mapping. Memory mapping is a process that copies a file onto a processes’ address space. This can allow for significant performance increases, especially for when dealing with storage mediums that have seek times. Writes to the file are also more efficient as they are not synchronously written back to disk the memory mapped file is edited. Like hardware developers, operating system designers try to create higher performance systems. One of the best approaches CentOS employs to do this is to maintain a cache of useful information. Linux uses at least four memory management related caches: buffer cache, page cache, swap cache, and hardware caches. The operating systems designers must weigh the benefits from caches like these with the costs of maintaining these caches. Also, “if the caches become corrupted, the system will crash” (Rusling, 1999).

Process Scheduling

As previously stated, Linux is a time sharing system that supports preemption. Consequently, the process scheduler is a major component of the operating system. The stock process scheduler is currently the “Completely Fair Scheduler”. This scheduler is focused on giving processes a fair amount of processor and does so by maintaining a red-black tree. Red black trees where invented by Rudof Bayer and are “self-balancing, which means that no path in the tree will ever be more than twice as long as any other” (Jones, 2009). Also, since tree operations happen in O(log n) time, editing the tree is very efficient. Priorities in Linux are implemented as a nice level. It is also noteworthy that the Completely Fair Scheduler does not use these nice levels directly, but instead uses the metric as a factor in determining a process’ decay. This decay calculation serves two purposes: first, it eliminates the need for multiple queues for different nice levels and second, it prevents starvation, a major problem with many scheduling algorithms.

Starvation happens when lower nice level processes are continually executed before higher nice level processes, leaving the low priority process endlessly waiting for processor time. In any operating system, there are resources with a finite number. Since CentOS is a multiprogramming environment deadlocks are possible. A deadlock is a state where two or more processes are waiting an indefinite period for each other to release resources needed to continue operations. The conditions that must be present in order for deadlocks to occur are mutual exclusion, hold and wait, no preemption and circular wait. Mutual exclusion means there is a resource that only one process can use at a time. Hold and wait means that a process is holding one or more resources and that process is waiting to acquire additional resources that are held by other processes. No preemption means that resources cannot be forced to release a resource.

Circular wait means that there exists a loop in the system resource-allocation graph. There are three methods for deadlock handling: use a protocol to avoid deadlocks, detect or recover from deadlocks or ignore the problem. Like many other operating systems, Linux chooses the third option, to ignore the problem. Without an algorithm to avoid or detect and recover from deadlocks, it is possible for a system to enter into a deadlocked state and not recognize what is happening, requiring an eventual manual restart. The operating system designers choose this method because cost in resources does not to justify the means when deadlocks happen so infrequently (Silberschatz et al., 2013, p. 323).

File System Handling

Like many operating systems, CentOS’s directory system uses a layered approach to file system handling. This layered structured reduces duplicated code and allows for code reuse but can increase overhead. Choosing how many layers and what the purpose of each layer is a major challenge in designing an operating system. The first layer in a Linux file system is separated into three main layers. The first layer is the file-system interface, which implements an interface for file access. Secondly, there is a layer named virtual file system, or VFS. This layer breaks apart generic file system operations from their actual implantations and supplies unique identifiers for each file. The layer actually implementing the file system type or protocol is the third layer (Silberschatz et al., 2013, p. 550 – 551).

Where some operating systems will first have a volume name then a path Linux makes an interesting distinction. Volumes are may be mounted nearly anywhere in the file path, with no clear separation of the device. Instead, a mount table exists that links prefixes of path names with specific devices. This makes file access for applications as uniform as possible. The operating system is also reasonable for file access control. In Linux, the basic handling of directories and file protection similar in that each has a set of bits that specify if the entity can be read, written, or executed. The first set of bits is for its owner, the next is for its group, and the final set is for everyone else (Silberschatz et al., 2013, p. 536).

CentOS also includes support for access control lists (ACLs). These lists allow permissions to be set for additional users and groups (Reptiler, 2009). Swap space is the location on disk used when paging memory is necessary. Linux supports two ways of doing this, though a raw partition and though the normal directory structure. Each method has benefits, when using a raw partition the performance is higher than using the normal directory structure, but may be inconvenient because a special partition must exist and adding more space repartitioning the disk or using swap space else ware. In contrast using the normal directory structure is very convenient, but inefficient (Silberschatz et al., 2013, p. 483). Relatively new Linux kernels, such as the one present in CentOS 6.4, support a unified buffer cache. Without this unified cache, when a file is memory mapped, it is double buffered though the page and buffer cache. With unified buffer caching, a flag is included to indelicate if any writes are synchronous or asynchronous and the page cache and buffer cache become one, increasing performance (Silberschatz et al., 2013, p. 568).

Handling I/O

Functions CentOS provides layers of abstraction for handling 10, greatly simplifying the process of sending and receiving information from various hardware types. At the application level, this OS provides a standardized interface to hide the differences of the many types of devices. On the other side of the kernel, device drivers are present and serve as a kind of translator to each hardware controller. This makes the 10 subsystem compatible with any hardware with a linux device driver. The Linux kernel is reasonable for other scheduling tasks besides processes. As an example, each individual block device can have its I/O schedulers chosen at runtime to best suit its need. The arguably best schedulers for various workloads are: NOOP, deadline, AS and CFQ.

When scheduling for devices that do not have seek times and consequently reordering the queue is not advantageous, NOPE is a simple FIFO scheduler that is most likely the best choice. Deadline is a lightweight scheduler with a hard limit on latency is needed. AS tries to future improve deadline, as it is conceptually similar, but its additional heuristics are sometimes counterproductive. CFQ is the current default 10 scheduler; similar to the process scheduler it tries to sustain fair I/O bandwidth to each process (Ephemient, 2009). Linux’s I/O subsystem is also responsible for buffering, caching, and spooling. Buffering is a memory area that exists for two reasons: 1) in case there is a mismatch between the speeds of a producer and consumer of a memory stream or 2) if there are different requirements for data transfer sizes. Caching information can speed up computation greatly by storing data in fast memory and non-synchronous updating the slower record as convenient. Spooling referees to a spool or buffer that holds output for devices that can only serve one job at a time (Silberschatz et al., 2013, p. 597 – 607). One common instance where a spool is used is for printing.

Programmer Interface

There are three main parts of CentOS that programmers must be aware of when developing software for the operating system. First, the Kernel maintains important abstractions of the operating systems, virtual memory, and processes. The Linux kernel has the ability to load and unload parts of its self on demand. These loadable parts of the kernel are called kernel modules. For example, a device driver for an input device may not be loaded unless it is currently connected to the system. Second, the system libraries contain a set of functions that applications can use to interact with the kernel. The most important system library is the C library which implements two main functionalities.

First, it provides the standard C library. Second, it creates interfaces for the user mode side of the Linux system and other critical system-level components. Third, this operating system comes with system utilities that perform specialized management tasks. Some of these utilities are for configuring an aspect of the system while others run continually to handle various tasks. CentOS also includes many user utility programs, some of which are arguably the best low-level tools available (MrTelly, 2009). These tools allow programmers to avoid duplicating work that has previously been accomplished. For example sed, a stream editor, grep, a tool for filtering by means of regular expressions, and awk, a tool to edit files. One could think of the different components of the Linux operating system as layers. A developer for each layer needs to know about the components adjacent to the layer they are working on. For example, a kernel module developer will need to know about the Linux kernel while a user application developer may not. This is because the shared libraries are a layer between the application being developed and the kernel.

User Interface

CentOS comes with multiple user interfaces. The default interface is the bash shell interface for most types of installs. Using the shell in Linux is faster, less resource intensive, and for many tasks more convenient then using a GUI. For desktop installs, the gnome graphical user interface is installed by default. This gui can be installed anytime on any type of system installation though with the single command: yum -y groupinstall “Desktop” “Desktop Platform” “X Window System” “Fonts”( lInstall.shtml) but for nearly all tasks the GUI is unnecessary for server tasks. The author has found that combining the two user interfaces by running instances of a shell inside the gui provides the best aspects of each interface for desktop use.

Virtual Capabilities

CentOS supports being ran as a virtual machine as well as running virtual machines. In fact, one of the major changes in CentOS 6.4 is the addition of drivers that increase the operating systems efficiently while running on a Microsoft Hyper-V server have been included (CentOS 6.4 Release Notes, 2013). The operating system provides running virtual machines though Xen and KVM. Virtual machines fall into two catagories, paravirtualization and full-virtualization. Paravirtualization ports the guest operating system to a layer between the hardware and virtualized system where full-virtualization emulates hardware. Xen is an OS stack that supports both paravirtualization and full-virtualization. KVM is a kernel module that works with the default kernel, but only supports full-virtualization. (Virtualization on CentOS, 2010).

Advantages and Disadvantages

As an enterprise class operating system, CentOS provides older, more tested software that has a longer life cycle. As advantages, this software package set supplies the longer life span system administrators may be requiring for machines that will be running for years. It also provides the stability and security of tested applications. At the same time, this older software set provides a disadvantage given that the newest features of any particular package may not be available. If a user needs the latest versions of applications available, CentOS is not a good choice of Linux distribution (NedSlider, 2008). Another set of advantages and disadvantages comes with the fact CentOS is a free rebuild of Red Hat Linux. While CentOS does have support in the way of security updates, it relies on the community of users to support its other users, a disadvantage to many users. Another disadvantage is that an organization using CentOS is not fiscally supporting Red Hat, which may contribute to Red Hat going out of business in the future. An advantage to using CentOS is the money saved on a Red Hat subscription can be used for in house support staff. CentOS, as a form of Linux, is developer centric, where as other operating systems, such as windows, are user centric (MrTelly, 2009). This may be an advantage for developers writing code for servers or other developers. Likewise, this is a disadvantage for developers writing code for end users or end users themselves.


CentOS is a rebuild of Red Hat’s Enterprise Linux Operating System, making it a multi use, general purpose, time-sharing desktop and server operating system. This essay has covered topics including process management, interprocess communication, memory management, scheduling, file system handling and handling I/O functions. It has also covered major elements of the programming interface, the user interface elements, virtual capabilities of the operating system, and finally advantages and disadvantages of the operating system. I personally believe CentOS makes a great general purpose server operating system but prefer other Linux distributions for a desktop operating system.


  1. At and Batch. (n.d.). Red Hat Enterprise Linux Deployment Guide. CentOS. Retrieved from
  2. CentOS 6.4 Release Notes. (2013, May 21). CentOS. Retrieved from Notes/
  3. CentOS6.4 Ephemient. (2009, June 18). Selecting a Linux I/O Scheduler. Stack Overflow. Retrieved from
  4. FrontPage. (2013, November). CentOS. Retrieved from
  5. Goldt, S. (1995). Basic Concepts. Shared Memory. The Linux Programmers’ Guide. Available from
  6. Hunter, J. (2013, March). Add GNOME to a CentOS Minimal Install. Retrieved from Install.shtml
  7. Jones, T. (2009, December). Inside the Linux 2.6 Completely Fair Scheduler. Providing fair access to CPUs since 2.6.23. Developer Works. Retrieved from
  8. Love, R. (2007, September 18). Advanced File 1/0. Linux System Programming. Available from
  9. MrTelly. (2009, March). Does using linux benefit you as a programmer?. Stack Overflow. Retrieved from NedSlider. (2008, November 15). Outdated Repositories?. [Msg 2]. Message posted to
  10. Physical and Virtual Memory. (2005). Red Hat Enterprise Linux 4: Introduction to System Administration. CentOS. Retrieved from
  11. Reptiler. (2009, June). ACLs: Exteded file-permissions. Retrieved from
  12. Rusling, D. (1999). Memory Management. The Linux Kernel. Available from
  13. Silberschatz, A., Galvin, P., & Gagne, G. (2013). Operating system concepts (9th ed.). [Kindle version). Retrieved from Virtualization on CentOS. (2010, December).
  14. CentOS. Retrieved from

Cite this page

The Key Points and Elements in the Cent 6.4 Operative System. (2021, Sep 23). Retrieved from

👋 Hi! I’m your smart assistant Amy!

Don’t know where to start? Type your requirements and I’ll connect you to an academic expert within 3 minutes.

get help with your assignment