Smartphone Operating System (779883), страница 12
Текст из файла (страница 12)
Whywould this be necessary? Why should executive calls be barredfrom creating objects in the kernel? (Hint: think about the usefulnessof the servers in a microkernel.)13.Symbian OS has an object-oriented design. Survey our discussionof Symbian OS and flag places where object orientation wouldcomplement the design strategies.14.Symbian OS is designed for use on smartphones. Consider a smartphone platform and identify the forms of communication that itwould use. For each of these forms of communication, identify thetype of device I/O that could be used to implement that form.15.Consider your answer to the previous question.
Must Symbian OS bea real-time operating system? Are there portions of system operationthat do not have to operate in real time? How does the microkerneldesign of Symbian OS help reduce the need for real-time operation?3Kernel StructureA computer network is functioning at its best when no one notices it.When it is working properly, computers communicate with each otherwith ease and users pay no attention to how their web browser works orthat email must travel long distances to get to their computers. In reality,there are many subsystems that co-operate to make a working networkfunction properly.
When a web browser requests a web page and itsimply appears, it is easy to ignore the complicated layered structure thatunderlies the ease of a network’s function.The same can be said of the kernel structure of an operating system.When it works well, it is easy to ignore that it is even there. However, thestructure of an operating system’s kernel is at center of its character andessential to its proper function.
It is useful to examine what a kernel iscomprised of and how a kernel works. This chapter examines a kernel inseveral ways. We discuss how a kernel is put together, that is, what partsmake up a kernel. We then discuss how system calls interact with kernelcode and what paths a system call might make through the kernel. Wefollow with a similar discussion about interrupts. We wrap up the chapterby taking a hard look at an example: the Symbian OS kernel.3.1 How a Kernel Is Put TogetherThe design of a kernel is very important to the performance of thecomputer it runs on.
We discussed kernel design – especially monolithickernels and microkernels – and we noted how certain kernel designs work48KERNEL STRUCTUREbetter on specific types of computer platform. For example, we saw howkernels with a microkernel design work better on smartphone devices.Symbian OS is an operating system that has a microkernel architecture. Itis great example of a kernel that has a layered structure. We provide anoverview of that structure in this section.It is interesting to look at kernel design as a set of pieces. Onlysome of those pieces are actually running at any given time. From thisperspective, there are two types of component that a kernel is built from:active components and passive components.
We examine them in thissection.Kernel StructureA kernel is built in layers. The layers of a kernel structure reflect thefunctionality of that part of the kernel. Inner layers implement basic,primitive functions in such a way that these basics execute very quickly.Innermost layers are also the most privileged layers, able to access allcomponents of the operating system whenever they need to. As youlook from inner to outer layers, the functions of the layers get lessprimitive and privileges are taken away; you move out toward user-modeapplications requiring fewer kernel-mode privileges and functionality.Figure 3.1 shows the general Symbian OS kernel structure.• The nanokernel provides some of the most basic functions in SymbianOS.
Simple threads operating in privileged mode implement servicesUser-mode ApplicationsMicrokernel ServersSymbian OS kernelNanokernelMMFetelesockWservFigure 3.1 Layers in the Symbian OS kernelHOW A KERNEL IS PUT TOGETHER49that are very primitive. Included among the implementations at thislevel are scheduling and synchronization operations, interrupt handling and synchronization objects called mutexes and semaphores(we discuss these later).
Most of the functions implemented at thislevel can be pre-empted. Functions at this level are so primitive (sothat they are fast) that the nanokernel must not implement any kind ofcomplicated operation, such as dynamic memory allocation.• The Symbian OS kernel layer provides kernel functions needed by therest of the operating system.
Each operation at this level is a privilegedoperation and combines the primitive operations of the nanokernel toimplement more complex tasks. Complex object services, user-modethreads, process scheduling and context switching, dynamic memory,dynamically loaded libraries, complex synchronization objects andinterprocess communication are just some of the operations implemented by this layer. This layer is fully pre-emptible and interruptscan cause this layer to reschedule any part of its execution – even inthe middle of context-switching!• The server layer is typical of microkernel architectures. Operationsthat do not require complete privileged operations or that have acomplex implementation are pushed out to servers.
Server-basedfunctions typically govern specific areas of functionality, such ashandling the display or working with sockets, and usually run asuser-mode services. These areas of functionality require kernel-basedoperations only sporadically and therefore can sit outside the SymbianOS kernel layer.• The user-mode applications run almost completely in user mode andperform kernel-based operations either by interacting with servers orby making system calls that activate kernel-mode activity.It is instructive to look at the kernel structure from another perspective. Itis easy to think of the kernel as an always-on, executing set of code thatruns alongside application programs. This is not the case.
Only part ofthe kernel runs constantly; much of the kernel is implemented passively,set into operation by system calls and interrupt handlers.Active Kernel ComponentsActive kernel components are those parts of the kernel that execute alongwith other processes in the operating system. These kernel processes50KERNEL STRUCTUREtypically have higher priorities and high levels of protection. They areusually multithreaded to allow for multiple threads of access from threadsof execution in various processes.Active kernel components are active so that they can monitor thesystem in real time.
They field requests for kernel services, servicethose requests, load and unload system modules (the passive kernelcomponents), and perform all the bookkeeping that needs to be done.Active components assist with the working of passive components as theyfield requests and implement the requests in kernel mode. Consider someexamples.• Two processes want to communicate.
One of their implementationchoices is to pass data through global memory from one processto another. This global memory is maintained by the kernel andaccess is gained through kernel requests. Each process makes asystem call that sends a request to the kernel process. As we see inChapter 6, this request requires a mechanism called a semaphore thatcoordinates how each process accesses the global data.
All of thisaccess, from semaphores to global memory reading and writing, mustbe maintained by active kernel components.• An application begins execution by building a context, then switchinginto and out of contexts as the CPU is multiplexed between processes. Context-switching is managed by active kernel componentsin response to a voluntary relinquishing of the CPU, some kind ofI/O blocking or a timer event. Again, bookkeeping must be done andmemory must be managed to make sure processes switch contextsproperly.
In between process switches, other system duties must takeplace and the active components implement these as well.• An application wishes to manipulate an I/O device, for example,sending data to an IR port. Active kernel components are built withvarying degrees of peripheral support. Monolithic kernel structurestypically have a built-in set of device implementations.
Microkernelarchitectures, by contrast, are typically independent of peripheralimplementations. In all cases, it is highly likely that code is loadeddynamically to implement various portions of device I/O. The activecomponents of the kernel are involved in module loading and unloading and do these tasks as required by service requests.
In Symbian OS,for example, sending data through an IR port results in the loading ofseveral I/O drivers in sequence, in response to several kernel requests.HOW A KERNEL IS PUT TOGETHER51Let’s consider this last example a little more closely. In a freshly bootedsystem, the active components of a microkernel-based operating systemhave a very small memory footprint.
For example, the executing kernel inSymbian OS v8 uses about 200 KB of memory when it starts up. A requestto use the IR port on a device causes a series of events, orchestrated andimplemented by the executing kernel code. The executing kernel needsto add layers of code to implement the data exchange over IR. None ofthese layers are initially in memory and all of these layers represent aninitial performance hit as the kernel code initializes device drivers andstarts communication.The size of the executing kernel components have a direct impact onsystem performance through the use of memory and the time it takes toload additional modules that implement various features.
![](https://s.studizba.com/z.php?f=/templates/si/i/noavatar.png&w=100&h=100&t=1"){kind=avatar}
