Page 1

Ubuntu Mobile Operating System


Editor-in-Chief Le Roy Lewis 1000818

Lead Graphic Designer Ricardo Hyde 1000068 Photographer Gianni James 1004339


What is Ubunto? Ubuntu is an Operating System Ubuntu is Open Source. At the core Ubuntu is a Linux Operating System

It is based on the Debian Linux Distribution Ubuntu is, by extent, the largest Linux distribution as of polls taken in 2012.


Brief History on Ubuntu


Linux was already established as an enterprise server platform in 2004. But Open Source/free software was still not a part of everyday life for most computer users. Mark Shuttleworth gathered a small team of developers from one of the most established Linux projects – Debian - and set out to create an easy-to-use Linux desktop, Ubuntu. Ubuntu builds on the foundations of Debian’s architecture and infrastructure, but has a different community and release process. Debian is ‘the rock upon which Ubuntu is built’. “Ubuntu still is and always will be free to use, share and develop.”


Ubuntu on Mobile Devices


Ubuntu has allowed it to not only be proprietary desktop software but also a viable mobile computing system. From smartphones such as Google’s Android and the like, to tablets such as the newly introduced Nibbio or Kite from DaVinci Mobile Technology in Italy, Ubuntu is making name for itself in the mobile operating systems arena.

Now with an even growing faster growing developer community Ubuntu boasts a nicely established “app� store, Ubuntu Software Center , and continues to move forward as a contender to look out for.


Memory Management Memory management is the efficiency at which data can be accessed and is handled by the Memory Management Unit (MMU). Not only does the MMU manage the physical memory available on the system, it can also create and manage virtual memory. It does this by using space on the hard disk, called the swap space. At boot time, Ubuntu will typically display a large amount of free memory, as no processes have begun to access the system’s memory. As processes begin to run, Ubuntu will cache memory so that it is quickly available for the next session.


Ubuntu performs fundamental computer operations, such as distributing the file system physically on the hard drive. Linux fragments physical memory into three zones. Namely: ZONE_DMA - First 16MB of memory ZONE_NORMAL - 16MB - 896MB ZONE_HIGHMEN - 896MB - End


Process Management The scheduler consists of two arrays call a run queue that is processor independent. The first array known as the active list contains tasks that will be executed while the second array, the expired list contains the tasks that have already run. When a process is not completed because of the time quantum, it goes into the expired list. The expired list only becomes the active list when the current active array reaches 0; this continues until all tasks are completed. Every time a process enters the expired list the nice priority (how long the task sleeps) is recalculated.


Functions Fork(), Exec()

Description Creates Processes

Clone()

Creates a child Process

nice()

Changes the Priority

getpriority()

Get the maximum group priority

setpriority()

Set the group priority

sched_setscheduler()

Set the scheduling policy and priority

sched_setparam()

Set the priority

sched_yield()

Relinquish the processor voluntarily

sched_getpriority_min()

Get the minimum priority value

sched_getpriority_max()

Get the maximum priority value

sched_rr_get_ interval()

Get the time quantum for round-robin

sched_setaffinity()

Set the CPU affinity mask

sched_getaffinity()

Get the CPU affinity mask


Spinlocks and Semaphores are implemented in order to lock the kernel during the scheduling process. This technique is used for Symmetric Multiprocessing machines while for single processing machines the preemptive mechanism is engaged and disengaged. In the preemptive process the interrupts are prioritized and put into two types of classes. The first class can interrupt the second class but cannot interrupt a process from the same class. The Ubuntu OS uses mutexes for kernel synchronization. Threads obtain a mutex before accessing data from other threads, and release it afterwards. When mutexes are not accessible, the thread request will go into a mode called sleep mode. A mutex is a program object that allows multiple program threads to share the same resource, such as file access, but not simultaneously. A semaphore is an object that’s allows threads to share the same resource without interrupting each other. Eg. a semaphore will allow any number of processes to read from the resource, but only one can write to that resource at the same time.


Spinlock Mutexes This mutex a variation of a regular mutex and are adapted to not sleep. They wait for the thread holding the lock to release it and disable interrupts when necessary. Pool Mutexes This mutex does not utilize pieces of allocated memory as other mutxes, but they secure data with references to the structure along with itself. Read/Write Mutex This mutex allow for multiple threads to access protected data or single threads to solely access data. Readers are threads that allow only reading of data and writers are threads that can edit data.


File Management Linux uses the UNIX’s standard file-system model The VFS has two components •

One that specifies what file-system objects are allowed to look like

A layer of software to manipulate the objects

The VFS works with objects each one contains a pointer to a function table. The main VFS objects are: • The inode object • The file object • Superblock Object • Dentry object


Linux supports many different file systems, but common choices include the ext* family ), XFS, JFS. Most of the supported file systems make use of a journaling file system. What is a journaling file system ? It is a file system that keeps track of the changes that will be made in a journal before committing them to the main file system. The extended file system, or ext, was the first file system created specifically for the Linux kernel. It was the first implementation that used the virtual file system (VFS). There are other members in the extended file system family: • ext2, the second extended file system. • ext3, the third extended file system. • ext4, the fourth extended file system. a


The ext4 or fourth extended file system is a journaling file system for Linux, developed as the successor to ext3. Ext4 uses “extents� to improve performance for large files. What is an extent? An extent is a contiguous area of storage in a computer file system, reserved for a file. XFS is a high-performance journaling file Journal File System or JFS is a 128-bit journaling file system JFS dynamically allocates space for disk inodes as necessary. JFS uses a B+ tree to accelerate lookups in directories A B+ tree is an n-ary tree with a variable but often large number of children per node. Ubuntu also makes use of Access Control Lists (ACLs)


Device Management in Ubuntu

The Linux kernel manages the physical devices in the system. Ubuntu has support for all types of hardware built into the kernel. Every physical device has its own hardware controller. Each hardware controller has its own control and status registers (CSRs) and these differ between devices. Instead of putting code to manage the hardware controllers in the system into every application, the code is kept in the Linux kernel. The software that handles or manages a hardware controller is known as a device driver. The Linux kernel device drivers are, essentially, a shared library of privileged, memory resident, low-level hardware handling routines. Linux supports three types of hardware device: character, block and network.


There are many different device drivers in the Linux kernel (that is one of Linux’s strengths) but they all share some common attributes: Kernel Code Kernel interfaces Kernel mechanisms and services Loadable Configurable Dynamic

Revised Op Sys  

Revides!!!

Read more
Read more
Similar to
Popular now
Just for you