0% found this document useful (0 votes)
11 viewsRtos Chap
Real-Time Embedded Operatring Systems
Uploaded by
Eric WongCopyright
© © All Rights Reserved
Available Formats
Download as PDF or read online on Scribd
0% found this document useful (0 votes)
11 viewsRtos Chap
Real-Time Embedded Operatring Systems
Uploaded by
Eric WongCopyright
© © All Rights Reserved
Available Formats
Download as PDF or read online on Scribd
/ 47
a caeata:
11
Real-Time Embedded
Operating Systems:
Standards and
Perspectives
11.1 Introduction n2 Embed
J systems Handbook
performance, and power consumption: often, embedded systems are mass produced, thus reducing their
st is an important design goal: in addition, mobile battery-powered embedded systems, such as
lular phones, have severe power budget constraints to enhance their battery life
Bath these constraints have a profound impact on system performance, because they entail simplifying
fhe overall hardware architecture, rslucing clock speed, and keeping memory requirements oa minimum
wer, embedded computer systems often lack traditional peripheral devices, such asa disk driv
stems is some kind of real-time behavior
the strictness ofthis requirement varies with the application, but it isso common that, for example, mar
erating system vendors often use the two terms interchangeably, and refer to their products either as
rating systems for embedded applications
In general the term “embedded” is preferred when refering to smaller, uniprocessor computer systems,
ealtime” is generally used when referring to larger applianc
ower and hardware features in embedded systems contributes to shade this
of available computing
distinction,
rit examples of real-time systems include many kinds of widespread computer systems, from
like p
arge appliane uimer products such as printers and digital
fore, a real-time operating system must not only manage system resources and offer a well
et of services to application programs, like any other operating system docs, but must also
tees about the timeliness of such services and honor them, that is its behavior must be
for example, the maximum time the operating system will take to perform any service
fers must be known in advance
sto be a tight constrain, and implies that real-time does nor have the same meaning as “eal
vals, such as good resource utilization and
cause it often conflicts with other operating system
rexistence of real-time and nonreal-time jobs, and adds further
mplexity to the operating system duty
Also, it is highly desirable that a real-time operating system optimiza
some oper.
ngystem parameters,
inly context switch timeand interrupt latency, which have a profound inluence on the overall response
time of the system to events; moreover, in embedded systems, the operating system footprin
that is its memory requirements, must be kept to a minimum to reduce costs
st. but not the least, due tothe increasing importance of open system architectures in software desig,
the operating system services should! be made available to the real-time application through a standard
lication programming interface. This approach promotes code re
interoperability, and portability
nd reduces the software maintenance cost
hi
1 issues of operating systems and on how these concepts have been put in practice, Section 11.3
discusses the main set of international perating system server processes running in user mode, leaving a minimal microkernel and reducing to
n absolute minimum the amount of privileged operating system code. Applications request operating
stem services by sending a message to the appropriate operating system server and waiting Fora reply
The main purpose ofthe microkernel isto handle the communication between applicationsand servers,
ree an appropriate security policy on such communication, and to perform some critical operating
ters, that would be difficult, or inet
junctions, such as accessing UO device re
3 to do from,
his kind of design makes the operating system easier to manage and maintain. Also, the message
passing interface between user processes and operating system components encourages modularity and
forces a clear and well-understood structure on operating system components
Moreover, the reliability of the operating system is increased: since the operating system serve
user mode, ifone of them fails some operating system functions will no longer be available, but the system
will not crash, Moreover, the failed compone
can be rest
arted and replaced without shutting down the
ole system.
st, the design is easily extended to distributed systems, where operating system functions are split
ross a set of distinct machines connected by a communication network. This kind of systems are very
promising in terms of performance, scalability, and fault tolerance, especially for large and complex
real-time applications,
By contrast, making the mess
c-passing communication mechanism efficient can be a critical isue,
P
in monolithic and layered systems,
aly for distributed systems, and the system call invocation mechanism induces more overhead than
tests are handled by transforming them into messages directed tothe appropriate interrupt
roper runs in interrupt service modeand performs
the minimum amount of work strictly required by the hardware, then synthesizes a message and sends it
to-an interrupt service task. In turn, the interrupt service task concludes interrupt handling running in
handling askas soon as possible: the interrupt hand
user mode. Being an ordinary tas
the intereupt service tak can, a leas in principe, invoke the full range
including blocking synchronization primitives, and must not concern itself
with excessive usage ofthe interrupt service processor mode. On the other hand, the overhead related to
interrupt handling increases, because the activation ofthe interrupt service task requires a task switch.
of operating systems based on virtual machines revolves
‘ound the basic observation that an operating system must perform two essential functions: mult
programming and system services.
systems fully separate these functions and implement them as two distinct
om
ating system components: a virtual machine monitor that runs in privileged mode, implements
multiprogramming, and provides many virtual processors identical in al tespects to the real processor it
cE
runs on,and one of more guest
rating systemsthat run on the virtual processors, and implement system
° an run different operating systems, and they must not necessarily be
ate of being run in a virtual machine. In the oldest approach to virtual machine implementation,
sguest operating systems are given the ilusion of running in privileged mode, but are instead constrained
to operate in user mode: in this way, the virtual machine monitor is able to intercept all privileged
instructions issued by the guest operating systems, check them against the security policy of the system,
ind then perform them on behalf ofthe guest operating system itself
interrupt handling is implemented ina similar way: the virtual machine me
or catches all interrupt
requests and then redirects them to the appropriate guest operating system handler, reverting 10 ser
node inthe proces; thus, the virtual machine monitor can intercept ll privileged instructions issued by
he guest interrupt handler, and a
in check and perform them as appropriate.
Real-Time
The fll
isolation of
fils, it does
and a gener
By contra
it Feasible ar
A variant
rom the ph
byte code or
More sop
11.2.2 PB
A convenien|
of cooper
and encom
including th
Im additic
sharing the
the operatin
the addr
hhetween thee
within a pre
sunong thee
swother thre
As a cons
1 keep over
implex rea
Another i
A processes
trouble to-¢ ut the systen
ng down th
erhead than
teinterrupt
vd performs
nd sends i
running in
full range
1 related to
«switch
os revolves
ssarily be
astrained
interrupt
ssued by
Heal*Time Embedded Operating Systems: Standards and Perspectives us
he full separation of roles and the presence ofa relatively small, centralized arbiter of all interactions
Jbetwren virtual machines has the advantage of making the enforcement of security policies easier. The
elation of virtual machines from each other also enhances reliability because even if one virtual machine
fails it does not bring down the system as a whole. In addition, itis possible to run a distinct operating
‘ystem in each virtual machine thus supporting, for example, the orderly coexistence between a real-time
sd « general-purpose operating system,
fy contrast, the perfect implementation of virtual machines requires hardware assistance, both to make
Wi fesible and to be able to emulate privileged instructions with a reasonable degree of efficiency
‘A variant of this design adopts an interpretive approach, and allows the virtual machines to be differen
the physical machine, For example, Java programs are compiled into byte-code instructions suitable
machine. On the target platform an interpreter executes the
tm
fie execution by an abstract Java virtu
Ipyte code on the physical processor, thus implementing the virtual ma
‘More sophisticated approaches to virtual machine implementation are also possible, the most common
‘one being on-the-fly code generation also knowin as just-in-time compilation,
2 Process and Thread Model
‘convenient and easy to understand way to design real-time software applications i to organize them asa
set of cooperating sequential processes. A process is an activity namely the activity of executing a program,
and encompasses the program being executed, the data it operates on, and the current processor state,
‘including the program counter and registers. In particular, each process has its own address space
In addition, itis often convenient to support multiple threads of control within the same process
sharing the same address space. Threads can be implemented for the most part in user mode, without
the operating systems kernel intervention; moreover, when the processor is switched between threads
the address space remains the same and must not be switched. Both these facts make processor switching
between threads very fst with respect to switching between processes, On the other hand, since all threads
Within a process share the same address space, there can be only a very limited amount of protection
among them with respect to memory access; hence, for example a thread is allowed to pollute by mistake
another thread’s data and the operating system has no way to detect errors of ths kind,
‘As a consequence, many small operating systems for embedded applications only support threads
to keep overheads and hardware requirements to a minimum, while larger operating systems for more
complex real-time applications offer the user a choice between a single or multiple process model to
enhance the reliability of complex systems,
Another important operating system design issue is the choice between static and dynamic creation
‘of processes and threads: some operating systems, usually oriented toward relatively simple embedded
applications, only support static tasks, that is, all tasks inthe system are known in advance and it is not
possible to create and destroy tasks while the system is running: thus, the total number of task in the
system stays constant forall its life. Other operating systems allow us to create and destroy tasks at runtime
by means ofa system call
Dynamic task creation has the obvious advantage of making the application more flexible, but it
increases the complexity of the operating system, because many operating system data structures, frst
of all the process table, must be allocated dynamically and their exact size cannot be known in advance.
In addition, the application code requires a more sophisticated error-handling strategy, with its associated
-ads, because it must be prepared to cape with the inability ofthe operating system to create a new
task, due to lack of resources
11.2.3 Processor Scheduling
‘The scheduleris one ofthe most important components ofa real-time operating system, asi is responsible
for deciding to which runnable threads he available processors must be assigned, and for how long. Among,
dynamic schedulers — that is schedulers that perform scheduling computations at runtime — while the 16 Embedded Systems Handbook
pplication is running, several algorithms are in use and offer different tradeoffs between real-time
Predictability, implementation complenity, and overhead.
Since the optimum compromise often depends on the application’s characteristics, most real-time
pperating systems support multiple scheduling policies simultaneously and the responsibilty of a correct
it depending on their signal number, The pthxead_eigmask function allows the calling thread to
am hange (or both) its signal mask. A signal mask can be set up and manipulated by means of
jptyset initialize a signal mask so that al signals are excluded from the mask.
tializes a signal mask so that all signals are ietudedin the mask
given a signal mask and a signal number, adds the specified signal tothe signal maski
has no effect ifthe signal was already in the mask
given a signal mask and a signal number, removes the specified signal from the signal
i has no effect if the signal was not in the mask.
ber: given a signal mask and a signal number, checks whether the signal belongs to th
Real-Tim,
A signal
successfull
Dn the
of the
passedasa
and contr
SIGRTME
pending, ¢
It shoul
that it wish
precedenci
associated
to specify
The way
signal is di
app
We there
anit ds
prncessle
113.5 ems Handly
in addition i
ler, setting thi
£ imterruptible
stem calls th
sstarted by th
1 to which th
signa in the
it proceeds
ing delivered
A
Meal-Time Embedded Operating Systems: Standards and Perspectives 47
Asignal can be delivered toa thread if and only if that thread does not block the signal; when a signal is
successfully delivered to a thread, that thread executes the process-level action associated with the signal
‘On the other hand, a thread may perform an explicit wait for one or more kinds of signals, by means
‘ofthe sigwait function; that function stops the execution of the calling thread until one of the signals
jpesed as argument to sigwait is conveyed to the thread, When this occurs, the thread acceprsthe signal
tnd continues past the sigwait function, Since the standard specifies that signals in the range from
GIGRTMIN to SIGRTMAX are subject to a priority hierarchy, when multiple signals in this range are
pending, the sigwa:
Tt should also be noted that for this mechanism to work correctly, the thread must block the signals
that it wishes to accept by means of sigwait (through its signal mask), otherwise signal delivery takes
precedence.
wo, more powerful, variants of the eigwait function exist: sigwa:
argument used to return additional information about the signal just accepted, including the information
associated withthe signal when it was fist generated; furthermore, sigt imedwa:
tospecify the maximum amount of time that shal be spent waiting fora signal to arr
The way in which the system selects a thread within a process to convey a signal depends on where the
shall consume the lowest-numbered one
nfo has an additional
also allows the caller
signal is directed
4 If the signal is directed toward a specific thread, only that thread is a candidate for delivery or
acceptance,
+ If the signal i directed to a process asa whole, any thread belonging to that process isa candidate
to receive the signal; in this case, the system selects exactly one thread within the process with the
appropriate signal mask (for delivery), or performing a suitable sigwait (for acceptance)
If there is no suitable thread to convey the signal when itis first generated, the signal remains pending
until its delivery oF acceptance becomes possible, by following the same rules outlined above, or the
process-level action associated with that kind of signal is changed and set to ignore it Inthe latter case,
the system forgets everything about the signal, and all other signals ofthe same kind.
1
The main interprocess synchronization and communication mechanisms offered by the standard are the
Interprocess Synchronization and Communication
semaphore and the message queue, both described in Section 11.2.4. The blocking synchronization prim
itives have a nonblocking and a timed counterpart, to enhance their real-time predictability. Moreover,
‘multithreading support also adds support for mutual exclusion devices, condition variables, and other
synchronization mechanisms. The scope ofthese mechanisms can be limited to threads belonging to the
same process to enhance their performance,
11.3.5.1 Message Queues
ypen function ether creates or opens a message queue and.
inthe system, each message queue is uniquely identified by a nam, like a fle. This function returns @
message queue descriptor that refers to and uniquely identifies the message queue; the descriptor must be
passed to all other functions that operate on the message queue.
Conversely,miq_c1Lose removes the association between the message queue descriptor and its message
queue. Asa result, the message queue descriptors no longer valid after successful return from ths function.
Last, the mq_unl ink function removes a message queue, provided no other processes reference its if this
ynnects it with the calling process
is not the case the removal is postponed until the reference count drops to zero.
The number of elements that message queue is able to buffer, and their maximum size, are constant
forthe lifetime of the message queue, and are set when the message quete is first created.
Thema_send and mq_receive functions send and receive a message to and from a message queue
respectively Ifthe message cannot be immediately stored or retrieved (eg, when mq_sendisexecuted on
4 full message queue) these functions block as long as appropriate, unless the message queue was opened 1.18 Embedded Systems Handbook
ith the nonblocking option set if us isthe case, these functions return immediately if they are unable
The mq_timedsend and mq_timedreceive functions have the same behavior, but allow the
-rbound on the amount of time they may spend waiting.
The standard allows to associate a priority to each message,
caller to place an up
ind specifies thatthe queueing policy of
message queues must obey the priority so that, for example, mq_receive retrieves the highest-priority
message that is currently stored in the queve.
The mq_not fy function allows the caller to arrange forthe asynchronous notifi
ation of message
e status of the queue transitions from empty to nonempty,
srrival at an empty message queue, when
according to the mechanism described in Section 11.3.4 The same function also allows the caller to
move a notification request it made previously.
e process may be registered for notification by a message queue. The registration
i removed implicitly when a notification is sent tothe registered process, or when the process owning the
“If
ter takes precedence, tha is, when a message arives at the queue, it satisfies the mq_receive and no
notification is sent
Last, the mq_getattr andmq_setattr functionsallow the caller to get and set, respectively some
attributes of the message queue dynamically after creation; these attributes include, for example, the
nonblocking flag just described and may aso include additional, implementation-specific lags.
pictly removes tin both cases, the message queue becomes available for anew registration.
cation request and an mq_zeceive call are pending on a given message queue, the
113,
Semaphores
Semaphores come in two favors: unnamed and named. Unnamed semaphores are created by the
2 junction and must be shared among processes by means of the usual memory sharing
mechanisms provided by the system. On the other hand, named semaphores created and accessed by the
‘em_open function exist as named objects in the system, like the message queues described above, and
an therefore be accessed by name. Both functions, when successful, associate the calling process with the
semaphore and return a descriptor for it
Depending on the kind of semaphore, either the sem_dest roy (for unnamed semaphores) of the
enclose function (for named semaphores) must be used to remove the association between the
alling process and a semaphore.
med semaphores, the sem_dest roy function also destroys the semaphore; instead, named
semaphores must be removed from the system with a separate function, sem_un ink.
h kinds of semaphore, a set of functions implements the classic P and V primitives, namely
* The sem_wait function performs a P operation on the semaphore; the sem_trywait and
.n_ imedwait functions perform the same function in polling mode and with a user-specified
# The sem_post function performs a V operation on the semaphore
The sem_getvalue function has no counterpart in the definition of semaphore found in
literature and returns the current value of a semaphore.
11.3.5.3 Mutexes
A mutexisa very specialized binary semaphore that can only be used to ensure the mutual exclusion among
‘multiple threads it is therefore simpler and more efficient than a full-fledged semaphore. Optionally, itis,
possible to associate to each mutex a protocol to deal with priority inversion,
The pthread_mutex_init function initializes a mutex and prepares it for use; it takes an attribute
‘object as argument, working according to the general mechanism described in Section 11.3.1 and useful
o specify the atributes ofthe mutex like, for example, the priority inversion protocol to be used fori
When default mutex attributes are appropriate, a static initialization technique is also available: in
particular, the macro PTHREAD 1 ETIALIZER can be used to initialize a mutex that the
pplication has statically allocated.
EX,
Real-Time |
The follow
= Thep
the p
Additiona
pthread s
the caller 0
ceiling proto
11354 €
Asetof conc
anism simila
language lew
Aconditic
this function
be created, a
appropriate,
that the appl
Then, the
= Each
begin
To bl
giving
cond)
the p
of ti
«Inside
block
condi
often
© Avar
uunble
When n
read
1355s
joes ms Handbook
scing policy 0
ighest-priority
he regis
ss owing the
age queue, the
coessed by th
ved above, and
ocess with th
stead, named
aser-specified
usion among
san attribute
1 and useful
used fori
available
Snape
#
ane ee
11.19
Real-Time Embedded Operating Systems: Standards and Perspectives
In any case,the pthread_mutex_dest roy function destroys a mutex
The following main functions operate on the mutex after creation:
# The pthread_mutex_lock function locks the mutex ifit is free; otherwise, it blocks until the
read_mutex_trylock function does the
mutex becomes available and then locks ithe pt
ame, but returns to the caller without blocking ifthe lock cannot be acquired immediately;
the pthread, mutex_timedlock function allows the caller to specify a maximum amount of
time to be spent waiting forthe lock to become available.
+ The pthread_mutex_unlock function unlocks a mutex.
‘Additional functions are defined for particular flavors of mutexes; for example, the
and pthread_mutex_setpriocei ling functionsallow
pthread_mutex_getpr:
the caller to get and st, respectively the priority celing of a mutex, and make sense only if the priority
ceiling protocol has been selected for the mutex, by means ofa suitable setting of it attributes
11.3.5.4 Condition Variables
‘Aset of condition variables, in concert with a mutex can be used to implement a synchronization mech
anism similar to the monitor without requiring the notion of monitor to be known at the programming
language level
"A condition variable must be initialized before use by means of the pthread_cond_init function,
this fanction takes an atribute object as argument, which can be used to configure the condition variable to
be created, according to the general mechanism described in Section 11.3.1. When default attributes are
appropriate, the macro PTHREAD_COND_INITIALTZER is available to initialize a condition variable
thatthe application has statically allocated
Then, the mutex and the condition variables can be used as follows:
1 Fach procedure belonging to the monitor must be explicitly bracketed with a mutex lock at the
beginning, and a mutex unlock atthe end.
fe To block on a condition variable, a thread must call the pehread_cond_wait function
giving both the condition variable and the mutex used to protect the procedures of the mon
ftor as arguments. This function atomically unlocks the mutex and blocks the caller on the
‘condition variable; the mutex will be reacquired when the thread is unblocked, and before
‘read_cond_wait. To avoid blocking for a (potentially) unbound time,
returning from pt
the pthread_cond_timedwait function allows the caller to specify th
of time that may be spent waiting forthe condition variable to be signaled,
« Inside a procedure belonging to the monitor, the pthread_cond_signal function, taking
a condition variable as argument, can be called to unblock at least one of the threads that are
blocked on the specified condition variable; the call has no effect if no threads are blocked on the
condition variable ther relaxed specification of unblocking atleast one thread, instead of
teactly one, has been adopted by the standard to simplify the implementation of condition variables
‘on multiprocessor systems, and to make it more efficient, mainly because condition variables are
often used as the building block of higher-level synchronization primitives.
‘Avariant of pthread_coné_signal, called pthread_cond_broadcast, is available to
‘unblock al threads that are currently waiting on a condition variable. As before, ths function has
no effect if no threads are waiting on the condition variable.
When no longer needed, condition variables shall be destroyed by means of the
pthread_cond_destroy function, to save system resources.
11,355 Shared Memory
Except message queues all PC mechanisms described so far only provide synchronization among threads
and processes and not data sharing. 11.20 Embedded Systems Handbook
Moreover, while all threads belonging to the same process share the same address space, so that they
mplicitly and inherently share all their global data, the same isnot true for different processes; therefore,
POSIX standard specifies an interface to explicitly set up a shared memory object among multiple
sit with a
fle descriptor, whichis then returned to the caller. Inthe system, each shared memory object is uniquely
The shm_open function either creates or opens a new shared memory object and associa
identified by a name, like a fle, After creation, the state of a shared memory object, in particular all data
Shared memory object is unlinked and all active references to it are removed.
tera reboot ofthe
Instead, the standard does not specify whether a shared memory object remains valid
onversey, Close removes the association between a fle descriptor and the corresponding shared
memory object. Asa result, the file descriptors no longer valid after successful return from this function.
ssi, the shm_un1 ink function removesa shared memory object, provided no other processes reference
fe count drops to 2er0,
Itshould be noted thet the association between a shared memory object and a file descriptor belonging
‘pen, does not map the shared memory into the address space
ening a shared memory object does not make the shared data
i: if ths is not the case, the removal is postponed until the refere
to formed by sh,
alling process,
the proces. In other words, merely
the p
In order to perform the mapping, the mmap function must be called; since the exact details of the
address space structure may be unknown to, and uninteresting for the programmer, the same function
so provides the capability of choosing a suitable portion of the caller’saddress spacetto place the mapping
automatically. The function manmap removes a mapping.
11.3.6 Thread-Specific Data
All unteads belonging to the same process implicitly share the same address space so that they have shared
ss 1o all their global data. Asa consequence, only the information allocated on the thread's stack, such
junction arguments and local variable, is private to each thread.
n the other hand, is often useful in practice to have data structures that are private toa single thread,
nut can be accessed globally by the code of that thread. The POSIX standard responds to this need by
Jefining the concept of thread: specific daa, of which Figure 11.4 depicts the general usage.
fe function creates a thread-specfic data key visible to, and shared by,
sque objects used to access
ll threads in the process. The key values provided by this function are oj
thread-specific dat
n particular, the pair of functions
read_getspecific and pth
‘ead_setepecific take
Set, respectively a pointer uniquely bound with the given
a key as argument and allow the caller to get
Real-Time Er
key, and private
forthe life of t
An optional
a thread exits
associated with
with the previo
When it is
pthread_ke
function does +
the application
11.3.7 Me:
The standard a
mlock and ml
the pages that
locked,
“The lock op
prevents them
ngand mu
dduce undue an
csarrently not it
When the lo
function to rele
‘Other meme
cstablish a map
between multi
kinds of object
and the operat
file is mapped
he file was may
Finally it is
means of the n
hare
critical data int
11.3.8 Asy
Many operatin
them. Thus, f
stom has fin
one pending I
While this p
shows its Kim
+ 0 devi
introdu
# Iris of
parallel 1s Handb
stack, su
ewer
Real-Time Embedded Operating Systems: Standards and Perspectives 21
key-and privateto the calling thread. The pointer bound tothe key by pts
for the life ofthe calling thread, unles itis replaced by a subsequent call to pthread_se'
‘An optional destructor function may be associated with each Key when the key itself is created. When
a thread exits, ifa given key has a valid destructor, and the thread has a valid (i.e, not NULL) pointer
Associated with that key, the pointer is disassociated and set to NULL, and then the destructor is called
with the previously associated pointer as argument.
When it is no longer needed, a th
thread _key delete function on it. It should be noted that, unlike in the previous case this
function does nor invoke the destructor function associated with the key, so that i isthe responsibility o
to the key being deleted
ead_setapecific persists
specific data key should be deleted by invoking the
the application to perform any cleanup actions for data structures relate
11.3.7. Memory Management
The standard allows processes to lock parts oF all oftheir address space in main memory by means of the
nl
functions: in addition, mlocka1 also allows the caller to demand that all of
and mlocka’
the pages that will become mapped into the addres space ofthe process inthe future must be implicitly
locked,
“The lock operation both forces the memory residence of the virtual memory pages involved, and
prevents them from being paged out in the future. This is vital in operating systems that support demand
paging and must nevertheless support any real-time processing, because the peging activity could into
duce undue and hi
currently notin the main memory and must therefore be retrieved from secondary storag
reded, the process can invoke either the munLock or the mun’
function to release it and enable demand-paging o
‘Other memory management functions, suchas the mmap function already described in Section 11.3.5.
c calling process and a memory object, possibly shared
between multiple processes. The mapping facility is general enough; hence, it can also be used to map othe
‘unpredictable delays when a real-time process attempts to access a page that is
‘When the lock is no longe
establish a mapping between the address space oft
Kinds of objects, such as files and devices, into the address space ofa process, provided both the hardware
‘and the operating system have this capability, which is not mandated by the standard. For example, once
ail is mapped, a process can acess it simply by reading or writing the data atthe address range to which
the file was mapped.
Finaly, tis possible for a process to change the access protections of portions of its address space by
means of the mpr:
hardware. For example, to prevent inadvertent data corruption due to a software bug, one could protect
critical data intended for read-only usage against write access.
{ct function; in this cas, itis assumed that protections will be enforced by the
11.3.8 Asynchronous and List Directed Input and Output
Many operating systems carry out 1/0 operations synchronously with respect tothe process requesting
them. Thus, f
ample, f 2 proces invokes a fle ead operation, it stays blocked until the operating
hed it, eithe
‘one pending /O operation at any given time
While this programming modelis simple, intuitive, and perfectly adequate for general-purpose systems
system has fi
sully or unsuccessfully. As aside effect, any process cam have at most
«VO device access timings can vary widely, especially when an error occurs; hence itis not alwa
wise to suspend the execution of a process until the operation completes, because this would
introduce a source of unpredictability in the system
« It is often desirable, for example, to enhance system performance by exploiting VO hardware
parallelism, to start more than one VO operation simultaneously, under the control of a single
process. Embedded Systems Handbook
2
these equiremens the standard defines asc of fnctons 9 sartome or :o¥s 1) requests,
To satis
we parte with proces execution, and whose completion satus cen be retrieved,
to be carried out
seynchronously by the requesting process.
ee aoeeus und lst-dircted U0 functions revolve around the concep of asynchronous YO control
block struct aiocks this structure contains all the vaformation needed to describe an 1/0 operatios
nd contains members to:
«Specify the operation to be performed, ead or write
» reaiy the file on which the operation must be carried out by means of file descriptor.
eae what portion ofthe fie the operation will operate upon. by means of file offset and a
ansfer len
Foe enetalfer in memory tobe used to store or retrieve the data read fom, oF 10 bbe writen
to, the file
« Give a priority classification to the operation.
+ Request the asynchronous notification ofthe completion of the operation either by a signal or by
ee ynchronous execution ofa function, as described in Section 11.3.4
Then, the following functions are available
Theaio_read and a: tee functions take an 1/0 contol block a argument and schedule
Th 940" operation, respectively; both return tothe caller as soon a he reduest has been
weued for execution,
eee the 140_}istio fanction schedules ist of (Posibly seynchronow) vo
aaah described byan HO control block, wth single function al
see ea return functions allow the caller to retrieve the error aud 08
eee sea wth an VO contol block after the corresponding VO opersion has been
completed,
« Theaio_fsync function asynchronously forces all 1/0 operations associated with the file ind
ae Fhe 0 contro block pase as argument and currently queued 0 thes mchronized VO
completion state
a eeiio suspend function canbe used to lock the calling thread unt at least one of the HO
partion aascined with ast of HO contol blocks passed a argument completes, or up to 8
« Theaio_ cancel function cancels an UO operation that has not been completed yet.
11.3.9 Clocks and Timers
nea-time applications very often rely on iming information to opersie correctly; the POSIX standatd
known resolution and whose vale
‘The clock_gettine
pecifies support for one or more timing bass called lcs
eretrieved et will In the system, each clock has its own unique identi
ast ime functions get and st the value of clock, respective while the clock got
Sock Tetura the rsoltion ofa dock. Clock resolutions are implementation defined and cannot
avon proce; come operating systems allow the lock resolution wo be se at =e generation
Sn cations can set one or mare pe-process mers sing 2 spied dose ming
sa Aon. Pie cme. create function Each timer hasacurent ale an OP" ed
ae Yared with i The operating syste decrements the current value of inet ing
value asi timer expzes it nol the owning procs with an aeyncone nop
